From ec4edc1856d57ae0eefa949ef87ff71549167593 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Tue, 4 Aug 2020 20:09:10 -0400
Subject: [PATCH 15/18] FIXME: big renaming to drop '2' from class names

---
 gcc/analyzer/analyzer.h                    |   80 +-
 gcc/analyzer/checker-path.cc               |    6 +-
 gcc/analyzer/checker-path.h                |   16 +-
 gcc/analyzer/constraint-manager.cc         | 1295 +++--
 gcc/analyzer/constraint-manager.h          |  200 +-
 gcc/analyzer/diagnostic-manager.cc         |  118 +-
 gcc/analyzer/diagnostic-manager.h          |   18 +-
 gcc/analyzer/engine.cc                     |  283 +-
 gcc/analyzer/exploded-graph.h              |   47 +-
 gcc/analyzer/program-state.cc              |  810 +---
 gcc/analyzer/program-state.h               |  124 +-
 gcc/analyzer/region-model.cc               | 5073 +++++++-------------
 gcc/analyzer/region-model.h                | 1749 +++----
 gcc/analyzer/region-model2-impl-calls.cc   |  116 +-
 gcc/analyzer/region-model2-reachability.cc |   80 +-
 gcc/analyzer/region-model2-reachability.h  |   52 +-
 gcc/analyzer/sm-file.cc                    |    2 +-
 gcc/analyzer/sm-malloc.cc                  |    8 +-
 gcc/analyzer/sm-signal.cc                  |   18 +-
 gcc/analyzer/sm.h                          |    2 +-
 gcc/analyzer/store.cc                      |  512 +-
 gcc/analyzer/store.h                       |  158 +-
 22 files changed, 4352 insertions(+), 6415 deletions(-)

diff --git a/gcc/analyzer/analyzer.h b/gcc/analyzer/analyzer.h
index 9e2bdc95c4e..a97b0c1dc70 100644
--- a/gcc/analyzer/analyzer.h
+++ b/gcc/analyzer/analyzer.h
@@ -40,43 +40,43 @@ class superedge;
     class call_superedge;
     class return_superedge;
 
-class svalue2;
-  class region_svalue2;
-  class constant_svalue2;
-  class unknown_svalue2;
-  class poisoned_svalue2;
-  class setjmp_svalue2;
-  class initial_svalue2;
-  class unaryop_svalue2;
-  class binop_svalue2;
-  class sub_svalue2;
-  class unmergeable_svalue2;
-  class placeholder_svalue2;
-  class widening_svalue2;
-  class compound_svalue2;
-  class conjured_svalue2;
-typedef hash_set<const svalue2 *> svalue2_set;
-class region2;
-  class frame_region2;
-  class function_region2;
-  class label_region2;
-  class decl_region2;
-  class symbolic_region2;
-  class element_region2;
-  class offset_region2;
-  class cast_region2;
-  class field_region2;
-  class string_region2;
-class region_model2_manager;
-struct model2_merger;
+class svalue;
+  class region_svalue;
+  class constant_svalue;
+  class unknown_svalue;
+  class poisoned_svalue;
+  class setjmp_svalue;
+  class initial_svalue;
+  class unaryop_svalue;
+  class binop_svalue;
+  class sub_svalue;
+  class unmergeable_svalue;
+  class placeholder_svalue;
+  class widening_svalue;
+  class compound_svalue;
+  class conjured_svalue;
+typedef hash_set<const svalue *> svalue_set;
+class region;
+  class frame_region;
+  class function_region;
+  class label_region;
+  class decl_region;
+  class symbolic_region;
+  class element_region;
+  class offset_region;
+  class cast_region;
+  class field_region;
+  class string_region;
+class region_model_manager;
+struct model_merger;
 class store_manager;
 class store;
-class region_model2;
-class region_model2_context;
-  class impl_region_model2_context;
+class region_model;
+class region_model_context;
+  class impl_region_model_context;
 class call_details;
-class constraint_manager2;
-class equiv_class2;
+class constraint_manager;
+class equiv_class;
 
 class pending_diagnostic;
 class state_change_event;
@@ -99,7 +99,7 @@ class state_purge_per_ssa_name;
 class state_change;
 class rewind_info_t;
 
-class engine2;
+class engine;
 
 /* Forward decls of functions.  */
 
@@ -161,17 +161,17 @@ typedef offset_int byte_size_t;
 class region_offset
 {
 public:
-  static region_offset make_concrete (const region2 *base_region,
+  static region_offset make_concrete (const region *base_region,
 				      bit_offset_t offset)
   {
     return region_offset (base_region, offset, false);
   }
-  static region_offset make_symbolic (const region2 *base_region)
+  static region_offset make_symbolic (const region *base_region)
   {
     return region_offset (base_region, 0, true);
   }
 
-  const region2 *get_base_region () const { return m_base_region; }
+  const region *get_base_region () const { return m_base_region; }
 
   bool symbolic_p () const { return m_is_symbolic; }
 
@@ -189,12 +189,12 @@ public:
   }
 
 private:
-  region_offset (const region2 *base_region, bit_offset_t offset,
+  region_offset (const region *base_region, bit_offset_t offset,
 		 bool is_symbolic)
   : m_base_region (base_region), m_offset (offset), m_is_symbolic (is_symbolic)
   {}
 
-  const region2 *m_base_region;
+  const region *m_base_region;
   bit_offset_t m_offset;
   bool m_is_symbolic;
 };
diff --git a/gcc/analyzer/checker-path.cc b/gcc/analyzer/checker-path.cc
index 47cb425ba78..0bfb1ff9d9b 100644
--- a/gcc/analyzer/checker-path.cc
+++ b/gcc/analyzer/checker-path.cc
@@ -214,10 +214,10 @@ state_change_event::state_change_event (const supernode *node,
 					const gimple *stmt,
 					int stack_depth,
 					const state_machine &sm,
-					const svalue2 *sval,
+					const svalue *sval,
 					state_machine::state_t from,
 					state_machine::state_t to,
-					const svalue2 *origin,
+					const svalue *origin,
 					const program_state &dst_state)
 : checker_event (EK_STATE_CHANGE,
 		 stmt->location, node->m_fun->decl,
@@ -245,7 +245,7 @@ state_change_event::get_desc (bool can_colorize) const
 {
   if (m_pending_diagnostic)
     {
-      region_model2 *model = m_dst_state.m_region_model2;
+      region_model *model = m_dst_state.m_region_model;
       tree var = model->get_representative_tree (m_sval);
       tree origin = model->get_representative_tree (m_origin);
       label_text custom_desc
diff --git a/gcc/analyzer/checker-path.h b/gcc/analyzer/checker-path.h
index 8608d43954e..7fea1be704c 100644
--- a/gcc/analyzer/checker-path.h
+++ b/gcc/analyzer/checker-path.h
@@ -195,26 +195,20 @@ public:
   state_change_event (const supernode *node, const gimple *stmt,
 		      int stack_depth,
 		      const state_machine &sm,
-		      const svalue2 *sval,
+		      const svalue *sval,
 		      state_machine::state_t from,
 		      state_machine::state_t to,
-		      const svalue2 *origin,
+		      const svalue *origin,
 		      const program_state &dst_state);
 
   label_text get_desc (bool can_colorize) const FINAL OVERRIDE;
 
 #if 0
-  region_id get_lvalue (tree expr, region_model_context *ctxt) const
+  const region* get_lvalue (tree expr, region_model_context *ctxt) const
   {
     gcc_assert (m_dst_state.m_region_model);
     return m_dst_state.m_region_model->get_lvalue (expr, ctxt);
   }
-
-  const region2* get_lvalue2 (tree expr, region_model2_context *ctxt) const
-  {
-    gcc_assert (m_dst_state.m_region_model2);
-    return m_dst_state.m_region_model2->get_lvalue (expr, ctxt);
-  }
 #endif
 
   function *get_dest_function () const
@@ -225,10 +219,10 @@ public:
   const supernode *m_node;
   const gimple *m_stmt;
   const state_machine &m_sm;
-  const svalue2 *m_sval;
+  const svalue *m_sval;
   state_machine::state_t m_from;
   state_machine::state_t m_to;
-  const svalue2 *m_origin;
+  const svalue *m_origin;
   program_state m_dst_state;
 };
 
diff --git a/gcc/analyzer/constraint-manager.cc b/gcc/analyzer/constraint-manager.cc
index be51e79a4b9..d1e0a02d348 100644
--- a/gcc/analyzer/constraint-manager.cc
+++ b/gcc/analyzer/constraint-manager.cc
@@ -162,7 +162,7 @@ compare_constants (tree lhs_const, enum tree_code op, tree rhs_const)
    closed one.  */
 
 void
-bound2::ensure_closed (bool is_upper)
+bound::ensure_closed (bool is_upper)
 {
   if (!m_closed)
     {
@@ -178,10 +178,10 @@ bound2::ensure_closed (bool is_upper)
     }
 }
 
-/* Get "<=" vs "<" for this bound2.  */
+/* Get "<=" vs "<" for this bound.  */
 
 const char *
-bound2::get_relation_as_str () const
+bound::get_relation_as_str () const
 {
   if (m_closed)
     return "<=";
@@ -189,12 +189,12 @@ bound2::get_relation_as_str () const
     return "<";
 }
 
-/* struct range2.  */
+/* struct range.  */
 
-/* Dump this range2 to PP, which must support %E for tree.  */
+/* Dump this range to PP, which must support %E for tree.  */
 
 void
-range2::dump_to_pp (pretty_printer *pp) const
+range::dump_to_pp (pretty_printer *pp) const
 {
   if (m_lower_bound.m_constant)
     {
@@ -220,10 +220,10 @@ range2::dump_to_pp (pretty_printer *pp) const
     }
 }
 
-/* Dump this range2 to stderr.  */
+/* Dump this range to stderr.  */
 
 DEBUG_FUNCTION void
-range2::dump () const
+range::dump () const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -234,11 +234,11 @@ range2::dump () const
   pp_flush (&pp);
 }
 
-/* Determine if there is only one possible value for this range2.
+/* Determine if there is only one possible value for this range.
    If so, return the constant; otherwise, return NULL_TREE.  */
 
 tree
-range2::constrained_to_single_element ()
+range::constrained_to_single_element ()
 {
   if (m_lower_bound.m_constant == NULL_TREE
       || m_upper_bound.m_constant == NULL_TREE)
@@ -266,10 +266,10 @@ range2::constrained_to_single_element ()
 /* Eval the condition "X OP RHS_CONST" for X within the range.  */
 
 tristate
-range2::eval_condition (enum tree_code op,
+range::eval_condition (enum tree_code op,
 			tree rhs_const) const
 {
-  range2 copy (*this);
+  range copy (*this);
   if (tree single_element = copy.constrained_to_single_element ())
     return compare_constants (single_element, op, rhs_const);
 
@@ -326,7 +326,7 @@ range2::eval_condition (enum tree_code op,
 /* Return true if RHS_CONST is below the lower bound of this range.  */
 
 bool
-range2::below_lower_bound (tree rhs_const) const
+range::below_lower_bound (tree rhs_const) const
 {
   if (!m_lower_bound.m_constant)
     return false;
@@ -339,7 +339,7 @@ range2::below_lower_bound (tree rhs_const) const
 /* Return true if RHS_CONST is above the upper bound of this range.  */
 
 bool
-range2::above_upper_bound (tree rhs_const) const
+range::above_upper_bound (tree rhs_const) const
 {
   if (!m_upper_bound.m_constant)
     return false;
@@ -349,36 +349,36 @@ range2::above_upper_bound (tree rhs_const) const
 			    m_upper_bound.m_constant).is_true ();
 }
 
-/* class equiv_class2.  */
+/* class equiv_class.  */
 
-/* equiv_class2's default ctor.  */
+/* equiv_class's default ctor.  */
 
-equiv_class2::equiv_class2 ()
+equiv_class::equiv_class ()
 : m_constant (NULL_TREE), m_cst_sval (NULL), m_vars ()
 {
 }
 
-/* equiv_class2's copy ctor.  */
+/* equiv_class's copy ctor.  */
 
-equiv_class2::equiv_class2 (const equiv_class2 &other)
+equiv_class::equiv_class (const equiv_class &other)
 : m_constant (other.m_constant), m_cst_sval (other.m_cst_sval),
   m_vars (other.m_vars.length ())
 {
   int i;
-  const svalue2 *sval;
+  const svalue *sval;
   FOR_EACH_VEC_ELT (other.m_vars, i, sval)
     m_vars.quick_push (sval);
 }
 
-/* Print an all-on-one-line representation of this equiv_class2 to PP,
+/* Print an all-on-one-line representation of this equiv_class to PP,
    which must support %E for trees.  */
 
 void
-equiv_class2::print (pretty_printer *pp) const
+equiv_class::print (pretty_printer *pp) const
 {
   pp_character (pp, '{');
   int i;
-  const svalue2 *sval;
+  const svalue *sval;
   FOR_EACH_VEC_ELT (m_vars, i, sval)
     {
       if (i > 0)
@@ -394,14 +394,14 @@ equiv_class2::print (pretty_printer *pp) const
   pp_character (pp, '}');
 }
 
-/* Generate a hash value for this equiv_class2.  */
+/* Generate a hash value for this equiv_class.  */
 
 hashval_t
-equiv_class2::hash () const
+equiv_class::hash () const
 {
   inchash::hash hstate;
   int i;
-  const svalue2 *sval;
+  const svalue *sval;
 
   inchash::add_expr (m_constant, hstate);
   // TODO:
@@ -412,10 +412,10 @@ equiv_class2::hash () const
   return hstate.end ();
 }
 
-/* Equality operator for equiv_class2.  */
+/* Equality operator for equiv_class.  */
 
 bool
-equiv_class2::operator== (const equiv_class2 &other)
+equiv_class::operator== (const equiv_class &other)
 {
   if (m_constant != other.m_constant)
     return false; // TODO: use tree equality here?
@@ -426,7 +426,7 @@ equiv_class2::operator== (const equiv_class2 &other)
     return false;
 
   int i;
-  const svalue2 *sval;
+  const svalue *sval;
   FOR_EACH_VEC_ELT (m_vars, i, sval)
     if (sval != other.m_vars[i])
       return false;
@@ -435,16 +435,16 @@ equiv_class2::operator== (const equiv_class2 &other)
   return true;
 }
 
-/* Add SID to this equiv_class2, using CM to check if it's a constant.  */
+/* Add SID to this equiv_class, using CM to check if it's a constant.  */
 
 void
-equiv_class2::add (const svalue2 *sval)
+equiv_class::add (const svalue *sval)
 {
   gcc_assert (sval);
   if (tree cst = sval->maybe_get_constant ())
     {
       gcc_assert (CONSTANT_CLASS_P (cst));
-      /* FIXME: should we canonicalize which svalue2 is the constant
+      /* FIXME: should we canonicalize which svalue is the constant
 	 when there are multiple equal constants?  */
       m_constant = cst;
       m_cst_sval = sval;
@@ -457,13 +457,13 @@ equiv_class2::add (const svalue2 *sval)
    a possible leak).  */
 
 bool
-equiv_class2::del (const svalue2 *sval)
+equiv_class::del (const svalue *sval)
 {
   gcc_assert (sval);
   gcc_assert (sval != m_cst_sval);
 
   int i;
-  const svalue2 *iv;
+  const svalue *iv;
   FOR_EACH_VEC_ELT (m_vars, i, iv)
     {
       if (iv == sval)
@@ -482,20 +482,20 @@ equiv_class2::del (const svalue2 *sval)
 /* Get a representative member of this class, for handling cases
    where the IDs can change mid-traversal.  */
 
-const svalue2 *
-equiv_class2::get_representative () const
+const svalue *
+equiv_class::get_representative () const
 {
   gcc_assert (m_vars.length () > 0);
   return m_vars[0];
 }
 
-/* Comparator for use by equiv_class2::canonicalize.  */
+/* Comparator for use by equiv_class::canonicalize.  */
 
 static int
-svalue2_cmp_by_ptr (const void *p1, const void *p2)
+svalue_cmp_by_ptr (const void *p1, const void *p2)
 {
-  const svalue2 *sval1 = *(const svalue2 * const *)p1;
-  const svalue2 *sval2 = *(const svalue2 * const *)p2;
+  const svalue *sval1 = *(const svalue * const *)p1;
+  const svalue *sval2 = *(const svalue * const *)p2;
   if (sval1 < sval2)
     return 1;
   if (sval1 > sval2)
@@ -503,41 +503,41 @@ svalue2_cmp_by_ptr (const void *p1, const void *p2)
   return 0;
 }
 
-/* Sort the svalue2s within this equiv_class2.  */
+/* Sort the svalues within this equiv_class.  */
 
 void
-equiv_class2::canonicalize ()
+equiv_class::canonicalize ()
 {
-  m_vars.qsort (svalue2_cmp_by_ptr);
+  m_vars.qsort (svalue_cmp_by_ptr);
 }
 
 /* Get a debug string for C_OP.  */
 
 const char *
-constraint2_op_code (enum constraint2_op c_op)
+constraint_op_code (enum constraint_op c_op)
 {
   switch (c_op)
     {
     default:
       gcc_unreachable ();
-    case CONSTRAINT2_NE: return "!=";
-    case CONSTRAINT2_LT: return "<";
-    case CONSTRAINT2_LE: return "<=";
+    case CONSTRAINT_NE: return "!=";
+    case CONSTRAINT_LT: return "<";
+    case CONSTRAINT_LE: return "<=";
     }
 }
 
 /* Convert C_OP to an enum tree_code.  */
 
 enum tree_code
-constraint2_tree_code (enum constraint2_op c_op)
+constraint_tree_code (enum constraint_op c_op)
 {
   switch (c_op)
     {
     default:
       gcc_unreachable ();
-    case CONSTRAINT2_NE: return NE_EXPR;
-    case CONSTRAINT2_LT: return LT_EXPR;
-    case CONSTRAINT2_LE: return LE_EXPR;
+    case CONSTRAINT_NE: return NE_EXPR;
+    case CONSTRAINT_LT: return LT_EXPR;
+    case CONSTRAINT_LE: return LE_EXPR;
     }
 }
 
@@ -546,25 +546,25 @@ constraint2_tree_code (enum constraint2_op c_op)
    For example, given "x < y", then "x > y" is false.  */
 
 static tristate
-eval_constraint_op_for_op (enum constraint2_op c_op, enum tree_code t_op)
+eval_constraint_op_for_op (enum constraint_op c_op, enum tree_code t_op)
 {
   switch (c_op)
     {
     default:
       gcc_unreachable ();
-    case CONSTRAINT2_NE:
+    case CONSTRAINT_NE:
       if (t_op == EQ_EXPR)
 	return tristate (tristate::TS_FALSE);
       if (t_op == NE_EXPR)
 	return tristate (tristate::TS_TRUE);
       break;
-    case CONSTRAINT2_LT:
+    case CONSTRAINT_LT:
       if (t_op == LT_EXPR || t_op == LE_EXPR || t_op == NE_EXPR)
 	return tristate (tristate::TS_TRUE);
       if (t_op == EQ_EXPR || t_op == GT_EXPR || t_op == GE_EXPR)
 	return tristate (tristate::TS_FALSE);
       break;
-    case CONSTRAINT2_LE:
+    case CONSTRAINT_LE:
       if (t_op == LE_EXPR)
 	return tristate (tristate::TS_TRUE);
       if (t_op == GT_EXPR)
@@ -574,29 +574,29 @@ eval_constraint_op_for_op (enum constraint2_op c_op, enum tree_code t_op)
   return tristate (tristate::TS_UNKNOWN);
 }
 
-/* class constraint2.  */
+/* class constraint.  */
 
-/* Print this constraint2 to PP (which must support %E for trees),
-   using CM to look up equiv_class2 instances from ids.  */
+/* Print this constraint to PP (which must support %E for trees),
+   using CM to look up equiv_class instances from ids.  */
 
 void
-constraint2::print (pretty_printer *pp, const constraint_manager2 &cm) const
+constraint::print (pretty_printer *pp, const constraint_manager &cm) const
 {
   m_lhs.print (pp);
   pp_string (pp, ": ");
   m_lhs.get_obj (cm).print (pp);
   pp_string (pp, " ");
-  pp_string (pp, constraint2_op_code (m_op));
+  pp_string (pp, constraint_op_code (m_op));
   pp_string (pp, " ");
   m_rhs.print (pp);
   pp_string (pp, ": ");
   m_rhs.get_obj (cm).print (pp);
 }
 
-/* Generate a hash value for this constraint2.  */
+/* Generate a hash value for this constraint.  */
 
 hashval_t
-constraint2::hash () const
+constraint::hash () const
 {
   inchash::hash hstate;
   hstate.add_int (m_lhs.m_idx);
@@ -605,10 +605,10 @@ constraint2::hash () const
   return hstate.end ();
 }
 
-/* Equality operator for constraint2s.  */
+/* Equality operator for constraints.  */
 
 bool
-constraint2::operator== (const constraint2 &other) const
+constraint::operator== (const constraint &other) const
 {
   if (m_lhs != other.m_lhs)
     return false;
@@ -622,8 +622,8 @@ constraint2::operator== (const constraint2 &other) const
 /* Return true if this constraint is implied by OTHER.  */
 
 bool
-constraint2::implied_by (const constraint2 &other,
-			 const constraint_manager2 &cm) const
+constraint::implied_by (const constraint &other,
+			 const constraint_manager &cm) const
 {
   if (m_lhs == other.m_lhs)
     if (tree rhs_const = m_rhs.get_obj (cm).get_any_constant ())
@@ -634,8 +634,8 @@ constraint2::implied_by (const constraint2 &other,
 	      {
 	      default:
 		break;
-	      case CONSTRAINT2_LE:
-	      case CONSTRAINT2_LT:
+	      case CONSTRAINT_LE:
+	      case CONSTRAINT_LT:
 		if (compare_constants (rhs_const,
 				       GE_EXPR,
 				       other_rhs_const).is_true ())
@@ -645,28 +645,28 @@ constraint2::implied_by (const constraint2 &other,
   return false;
 }
 
-/* class equiv_class2_id.  */
+/* class equiv_class_id.  */
 
-/* Get the underlying equiv_class2 for this ID from CM.  */
+/* Get the underlying equiv_class for this ID from CM.  */
 
-const equiv_class2 &
-equiv_class2_id::get_obj (const constraint_manager2 &cm) const
+const equiv_class &
+equiv_class_id::get_obj (const constraint_manager &cm) const
 {
-  return cm.get_equiv_class2_by_index (m_idx);
+  return cm.get_equiv_class_by_index (m_idx);
 }
 
-/* Access the underlying equiv_class2 for this ID from CM.  */
+/* Access the underlying equiv_class for this ID from CM.  */
 
-equiv_class2 &
-equiv_class2_id::get_obj (constraint_manager2 &cm) const
+equiv_class &
+equiv_class_id::get_obj (constraint_manager &cm) const
 {
-  return cm.get_equiv_class2_by_index (m_idx);
+  return cm.get_equiv_class_by_index (m_idx);
 }
 
-/* Print this equiv_class2_id to PP.  */
+/* Print this equiv_class_id to PP.  */
 
 void
-equiv_class2_id::print (pretty_printer *pp) const
+equiv_class_id::print (pretty_printer *pp) const
 {
   if (null_p ())
     pp_printf (pp, "null");
@@ -674,38 +674,38 @@ equiv_class2_id::print (pretty_printer *pp) const
     pp_printf (pp, "ec%i", m_idx);
 }
 
-/* class constraint_manager2.  */
+/* class constraint_manager.  */
 
-/* constraint_manager2's copy ctor.  */
+/* constraint_manager's copy ctor.  */
 
-constraint_manager2::constraint_manager2 (const constraint_manager2 &other)
+constraint_manager::constraint_manager (const constraint_manager &other)
 : m_equiv_classes (other.m_equiv_classes.length ()),
   m_constraints (other.m_constraints.length ()),
   m_mgr (other.m_mgr)
 {
   int i;
-  equiv_class2 *ec;
+  equiv_class *ec;
   FOR_EACH_VEC_ELT (other.m_equiv_classes, i, ec)
-    m_equiv_classes.quick_push (new equiv_class2 (*ec));
-  constraint2 *c;
+    m_equiv_classes.quick_push (new equiv_class (*ec));
+  constraint *c;
   FOR_EACH_VEC_ELT (other.m_constraints, i, c)
     m_constraints.quick_push (*c);
 }
 
-/* constraint_manager2's assignment operator.  */
+/* constraint_manager's assignment operator.  */
 
-constraint_manager2&
-constraint_manager2::operator= (const constraint_manager2 &other)
+constraint_manager&
+constraint_manager::operator= (const constraint_manager &other)
 {
   gcc_assert (m_equiv_classes.length () == 0);
   gcc_assert (m_constraints.length () == 0);
 
   int i;
-  equiv_class2 *ec;
+  equiv_class *ec;
   m_equiv_classes.reserve (other.m_equiv_classes.length ());
   FOR_EACH_VEC_ELT (other.m_equiv_classes, i, ec)
-    m_equiv_classes.quick_push (new equiv_class2 (*ec));
-  constraint2 *c;
+    m_equiv_classes.quick_push (new equiv_class (*ec));
+  constraint *c;
   m_constraints.reserve (other.m_constraints.length ());
   FOR_EACH_VEC_ELT (other.m_constraints, i, c)
     m_constraints.quick_push (*c);
@@ -713,15 +713,15 @@ constraint_manager2::operator= (const constraint_manager2 &other)
   return *this;
 }
 
-/* Generate a hash value for this constraint_manager2.  */
+/* Generate a hash value for this constraint_manager.  */
 
 hashval_t
-constraint_manager2::hash () const
+constraint_manager::hash () const
 {
   inchash::hash hstate;
   int i;
-  equiv_class2 *ec;
-  constraint2 *c;
+  equiv_class *ec;
+  constraint *c;
 
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     hstate.merge_hash (ec->hash ());
@@ -730,10 +730,10 @@ constraint_manager2::hash () const
   return hstate.end ();
 }
 
-/* Equality operator for constraint_manager2.  */
+/* Equality operator for constraint_manager.  */
 
 bool
-constraint_manager2::operator== (const constraint_manager2 &other) const
+constraint_manager::operator== (const constraint_manager &other) const
 {
   if (m_equiv_classes.length () != other.m_equiv_classes.length ())
     return false;
@@ -741,13 +741,13 @@ constraint_manager2::operator== (const constraint_manager2 &other) const
     return false;
 
   int i;
-  equiv_class2 *ec;
+  equiv_class *ec;
 
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     if (!(*ec == *other.m_equiv_classes[i]))
       return false;
 
-  constraint2 *c;
+  constraint *c;
 
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     if (!(*c == other.m_constraints[i]))
@@ -756,24 +756,24 @@ constraint_manager2::operator== (const constraint_manager2 &other) const
   return true;
 }
 
-/* Print this constraint_manager2 to PP (which must support %E for trees).  */
+/* Print this constraint_manager to PP (which must support %E for trees).  */
 
 void
-constraint_manager2::print (pretty_printer *pp) const
+constraint_manager::print (pretty_printer *pp) const
 {
   pp_string (pp, "{");
   int i;
-  equiv_class2 *ec;
+  equiv_class *ec;
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     {
       if (i > 0)
 	pp_string (pp, ", ");
-      equiv_class2_id (i).print (pp);
+      equiv_class_id (i).print (pp);
       pp_string (pp, ": ");
       ec->print (pp);
     }
   pp_string (pp, "  |  ");
-  constraint2 *c;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     {
       if (i > 0)
@@ -783,11 +783,11 @@ constraint_manager2::print (pretty_printer *pp) const
   pp_printf (pp, "}");
 }
 
-/* Dump a representation of this constraint_manager2 to PP
+/* Dump a representation of this constraint_manager to PP
    (which must support %E for trees).  */
 
 void
-constraint_manager2::dump_to_pp (pretty_printer *pp, bool multiline) const
+constraint_manager::dump_to_pp (pretty_printer *pp, bool multiline) const
 {
   // TODO
   if (multiline)
@@ -798,14 +798,14 @@ constraint_manager2::dump_to_pp (pretty_printer *pp, bool multiline) const
   else
     pp_string (pp, " {");
   int i;
-  equiv_class2 *ec;
+  equiv_class *ec;
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     {
       if (multiline)
 	pp_string (pp, "    ");
       else if (i > 0)
 	pp_string (pp, ", ");
-      equiv_class2_id (i).print (pp);
+      equiv_class_id (i).print (pp);
       pp_string (pp, ": ");
       ec->print (pp);
       if (multiline)
@@ -820,7 +820,7 @@ constraint_manager2::dump_to_pp (pretty_printer *pp, bool multiline) const
     pp_newline (pp);
   else
     pp_string (pp, "{");
-  constraint2 *c;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     {
       if (multiline)
@@ -834,10 +834,10 @@ constraint_manager2::dump_to_pp (pretty_printer *pp, bool multiline) const
     pp_string (pp, "}");
 }
 
-/* Dump a multiline representation of this constraint_manager2 to FP.  */
+/* Dump a multiline representation of this constraint_manager to FP.  */
 
 void
-constraint_manager2::dump (FILE *fp) const
+constraint_manager::dump (FILE *fp) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -847,10 +847,10 @@ constraint_manager2::dump (FILE *fp) const
   pp_flush (&pp);
 }
 
-/* Dump a multiline representation of this constraint_manager2 to stderr.  */
+/* Dump a multiline representation of this constraint_manager to stderr.  */
 
 DEBUG_FUNCTION void
-constraint_manager2::dump () const
+constraint_manager::dump () const
 {
   dump (stderr);
 }
@@ -858,26 +858,26 @@ constraint_manager2::dump () const
 /* Dump a multiline representation of CM to stderr.  */
 
 DEBUG_FUNCTION void
-debug (const constraint_manager2 &cm)
+debug (const constraint_manager &cm)
 {
   cm.dump ();
 }
 
-/* Attempt to add the constraint LHS OP RHS to this constraint_manager2.
+/* Attempt to add the constraint LHS OP RHS to this constraint_manager.
    Return true if the constraint could be added (or is already true).
    Return false if the constraint contradicts existing knowledge.  */
 
 bool
-constraint_manager2::add_constraint (const svalue2 *lhs,
+constraint_manager::add_constraint (const svalue *lhs,
 				     enum tree_code op,
-				     const svalue2 *rhs)
+				     const svalue *rhs)
 {
   lhs = lhs->unwrap_any_unmergeable ();
   rhs = rhs->unwrap_any_unmergeable ();
 
   /* Nothing can be known about unknown values.  */
-  if (lhs->get_kind () == svalue2::SK_UNKNOWN
-      || rhs->get_kind () == svalue2::SK_UNKNOWN)
+  if (lhs->get_kind () == svalue::SK_UNKNOWN
+      || rhs->get_kind () == svalue::SK_UNKNOWN)
     /* Not a contradiction.  */
     return true;
 
@@ -895,8 +895,8 @@ constraint_manager2::add_constraint (const svalue2 *lhs,
       return false;
   }
 
-  equiv_class2_id lhs_ec_id = get_or_add_equiv_class2 (lhs);
-  equiv_class2_id rhs_ec_id = get_or_add_equiv_class2 (rhs);
+  equiv_class_id lhs_ec_id = get_or_add_equiv_class (lhs);
+  equiv_class_id rhs_ec_id = get_or_add_equiv_class (rhs);
 
   /* Check the stronger conditions on ECs.  */
   {
@@ -916,14 +916,14 @@ constraint_manager2::add_constraint (const svalue2 *lhs,
 }
 
 /* Attempt to add the constraint LHS_EC_ID OP RHS_EC_ID to this
-   constraint_manager2.
+   constraint_manager.
    Return true if the constraint could be added (or is already true).
    Return false if the constraint contradicts existing knowledge.  */
 
 bool
-constraint_manager2::add_constraint (equiv_class2_id lhs_ec_id,
+constraint_manager::add_constraint (equiv_class_id lhs_ec_id,
 				     enum tree_code op,
-				     equiv_class2_id rhs_ec_id)
+				     equiv_class_id rhs_ec_id)
 {
   tristate t = eval_condition (lhs_ec_id, op, rhs_ec_id);
 
@@ -939,13 +939,13 @@ constraint_manager2::add_constraint (equiv_class2_id lhs_ec_id,
   return true;
 }
 
-/* Add the constraint LHS_EC_ID OP RHS_EC_ID to this constraint_manager2,
+/* Add the constraint LHS_EC_ID OP RHS_EC_ID to this constraint_manager,
    where the constraint has already been checked for being "unknown".  */
 
 void
-constraint_manager2::add_unknown_constraint (equiv_class2_id lhs_ec_id,
+constraint_manager::add_unknown_constraint (equiv_class_id lhs_ec_id,
 					     enum tree_code op,
-					     equiv_class2_id rhs_ec_id)
+					     equiv_class_id rhs_ec_id)
 {
   gcc_assert (lhs_ec_id != rhs_ec_id);
 
@@ -956,11 +956,11 @@ constraint_manager2::add_unknown_constraint (equiv_class2_id lhs_ec_id,
     case EQ_EXPR:
       {
 	/* Merge rhs_ec into lhs_ec.  */
-	equiv_class2 &lhs_ec_obj = lhs_ec_id.get_obj (*this);
-	const equiv_class2 &rhs_ec_obj = rhs_ec_id.get_obj (*this);
+	equiv_class &lhs_ec_obj = lhs_ec_id.get_obj (*this);
+	const equiv_class &rhs_ec_obj = rhs_ec_id.get_obj (*this);
 
 	int i;
-	const svalue2 *sval;
+	const svalue *sval;
 	FOR_EACH_VEC_ELT (rhs_ec_obj.m_vars, i, sval)
 	  lhs_ec_obj.add (sval);
 
@@ -972,15 +972,15 @@ constraint_manager2::add_unknown_constraint (equiv_class2_id lhs_ec_id,
 
 	/* Drop rhs equivalence class, overwriting it with the
 	   final ec (which might be the same one).  */
-	equiv_class2_id final_ec_id = m_equiv_classes.length () - 1;
-	equiv_class2 *old_ec = m_equiv_classes[rhs_ec_id.m_idx];
-	equiv_class2 *final_ec = m_equiv_classes.pop ();
+	equiv_class_id final_ec_id = m_equiv_classes.length () - 1;
+	equiv_class *old_ec = m_equiv_classes[rhs_ec_id.m_idx];
+	equiv_class *final_ec = m_equiv_classes.pop ();
 	if (final_ec != old_ec)
 	  m_equiv_classes[rhs_ec_id.m_idx] = final_ec;
 	delete old_ec;
 
 	/* Update the constraints.  */
-	constraint2 *c;
+	constraint *c;
 	FOR_EACH_VEC_ELT (m_constraints, i, c)
 	  {
 	    /* Update references to the rhs_ec so that
@@ -1006,19 +1006,19 @@ constraint_manager2::add_unknown_constraint (equiv_class2_id lhs_ec_id,
       }
       break;
     case GE_EXPR:
-      add_constraint_internal (rhs_ec_id, CONSTRAINT2_LE, lhs_ec_id);
+      add_constraint_internal (rhs_ec_id, CONSTRAINT_LE, lhs_ec_id);
       break;
     case LE_EXPR:
-      add_constraint_internal (lhs_ec_id, CONSTRAINT2_LE, rhs_ec_id);
+      add_constraint_internal (lhs_ec_id, CONSTRAINT_LE, rhs_ec_id);
       break;
     case NE_EXPR:
-      add_constraint_internal (lhs_ec_id, CONSTRAINT2_NE, rhs_ec_id);
+      add_constraint_internal (lhs_ec_id, CONSTRAINT_NE, rhs_ec_id);
       break;
     case GT_EXPR:
-      add_constraint_internal (rhs_ec_id, CONSTRAINT2_LT, lhs_ec_id);
+      add_constraint_internal (rhs_ec_id, CONSTRAINT_LT, lhs_ec_id);
       break;
     case LT_EXPR:
-      add_constraint_internal (lhs_ec_id, CONSTRAINT2_LT, rhs_ec_id);
+      add_constraint_internal (lhs_ec_id, CONSTRAINT_LT, rhs_ec_id);
       break;
     default:
       /* do nothing.  */
@@ -1027,20 +1027,20 @@ constraint_manager2::add_unknown_constraint (equiv_class2_id lhs_ec_id,
   validate ();
 }
 
-/* Subroutine of constraint_manager2::add_constraint, for handling all
+/* Subroutine of constraint_manager::add_constraint, for handling all
    operations other than equality (for which equiv classes are merged).  */
 
 void
-constraint_manager2::add_constraint_internal (equiv_class2_id lhs_id,
-					      enum constraint2_op c_op,
-					      equiv_class2_id rhs_id)
+constraint_manager::add_constraint_internal (equiv_class_id lhs_id,
+					      enum constraint_op c_op,
+					      equiv_class_id rhs_id)
 {
-  constraint2 new_c (lhs_id, c_op, rhs_id);
+  constraint new_c (lhs_id, c_op, rhs_id);
 
   /* Remove existing constraints that would be implied by the
      new constraint.  */
   unsigned read_index, write_index;
-  constraint2 *c;
+  constraint *c;
   VEC_ORDERED_REMOVE_IF (m_constraints, read_index, write_index, c,
 			 (c->implied_by (new_c, *this)));
 
@@ -1050,13 +1050,13 @@ constraint_manager2::add_constraint_internal (equiv_class2_id lhs_id,
   if (!flag_analyzer_transitivity)
     return;
 
-  if (c_op != CONSTRAINT2_NE)
+  if (c_op != CONSTRAINT_NE)
     {
       /* The following can potentially add EQ_EXPR facts, which could lead
 	 to ECs being merged, which would change the meaning of the EC IDs.
 	 Hence we need to do this via representatives.  */
-      const svalue2 *lhs = lhs_id.get_obj (*this).get_representative ();
-      const svalue2 *rhs = rhs_id.get_obj (*this).get_representative ();
+      const svalue *lhs = lhs_id.get_obj (*this).get_representative ();
+      const svalue *rhs = rhs_id.get_obj (*this).get_representative ();
 
       /* We have LHS </<= RHS */
 
@@ -1082,12 +1082,12 @@ constraint_manager2::add_constraint_internal (equiv_class2_id lhs_id,
 	 that x == 4 (if x is an integer).  */
       for (unsigned i = 0; i < m_constraints.length (); i++)
 	{
-	  const constraint2 *other = &m_constraints[i];
+	  const constraint *other = &m_constraints[i];
 	  if (other->is_ordering_p ())
 	    {
 	      /* Refresh the EC IDs, in case any mergers have happened.  */
-	      lhs_id = get_or_add_equiv_class2 (lhs);
-	      rhs_id = get_or_add_equiv_class2 (rhs);
+	      lhs_id = get_or_add_equiv_class (lhs);
+	      rhs_id = get_or_add_equiv_class (rhs);
 
 	      tree lhs_const = lhs_id.get_obj (*this).m_constant;
 	      tree rhs_const = rhs_id.get_obj (*this).m_constant;
@@ -1104,8 +1104,8 @@ constraint_manager2::add_constraint_internal (equiv_class2_id lhs_id,
 		  && other->m_rhs == lhs_id)
 		{
 		  /* We must have equality for this to be possible.  */
-		  gcc_assert (c_op == CONSTRAINT2_LE
-			      && other->m_op == CONSTRAINT2_LE);
+		  gcc_assert (c_op == CONSTRAINT_LE
+			      && other->m_op == CONSTRAINT_LE);
 		  add_constraint (lhs_id, EQ_EXPR, rhs_id);
 		  /* Adding an equality will merge the two ECs and potentially
 		     reorganize the constraints.  Stop iterating.  */
@@ -1123,23 +1123,23 @@ constraint_manager2::add_constraint_internal (equiv_class2_id lhs_id,
 		      && !rhs_const
 		      && other_rhs_const)
 		    {
-		      range2 r (bound2 (lhs_const, c_op == CONSTRAINT2_LE),
-			       bound2 (other_rhs_const,
-				      other->m_op == CONSTRAINT2_LE));
+		      range r (bound (lhs_const, c_op == CONSTRAINT_LE),
+			       bound (other_rhs_const,
+				      other->m_op == CONSTRAINT_LE));
 		      if (tree constant = r.constrained_to_single_element ())
 			{
-			  const svalue2 *cst_sval
-			    = m_mgr->get_or_create_constant_svalue2 (constant);
+			  const svalue *cst_sval
+			    = m_mgr->get_or_create_constant_svalue (constant);
 			  add_constraint
 			    (rhs_id, EQ_EXPR,
-			     get_or_add_equiv_class2 (cst_sval));
+			     get_or_add_equiv_class (cst_sval));
 			  return;
 			}
 		    }
 
 		  /* Otherwise, add the constraint implied by transitivity.  */
 		  enum tree_code new_op
-		    = ((c_op == CONSTRAINT2_LE && other->m_op == CONSTRAINT2_LE)
+		    = ((c_op == CONSTRAINT_LE && other->m_op == CONSTRAINT_LE)
 		       ? LE_EXPR : LT_EXPR);
 		  add_constraint (lhs_id, new_op, other->m_rhs);
 		}
@@ -1154,24 +1154,24 @@ constraint_manager2::add_constraint_internal (equiv_class2_id lhs_id,
 		      && !lhs_const
 		      && rhs_const)
 		    {
-		      range2 r (bound2 (other_lhs_const,
-				      other->m_op == CONSTRAINT2_LE),
-			       bound2 (rhs_const,
-				      c_op == CONSTRAINT2_LE));
+		      range r (bound (other_lhs_const,
+				      other->m_op == CONSTRAINT_LE),
+			       bound (rhs_const,
+				      c_op == CONSTRAINT_LE));
 		      if (tree constant = r.constrained_to_single_element ())
 			{
-			  const svalue2 *cst_sval
-			    = m_mgr->get_or_create_constant_svalue2 (constant);
+			  const svalue *cst_sval
+			    = m_mgr->get_or_create_constant_svalue (constant);
 			  add_constraint
 			    (lhs_id, EQ_EXPR,
-			     get_or_add_equiv_class2 (cst_sval));
+			     get_or_add_equiv_class (cst_sval));
 			  return;
 			}
 		    }
 
 		  /* Otherwise, add the constraint implied by transitivity.  */
 		  enum tree_code new_op
-		    = ((c_op == CONSTRAINT2_LE && other->m_op == CONSTRAINT2_LE)
+		    = ((c_op == CONSTRAINT_LE && other->m_op == CONSTRAINT_LE)
 		       ? LE_EXPR : LT_EXPR);
 		  add_constraint (other->m_lhs, new_op, rhs_id);
 		}
@@ -1180,41 +1180,41 @@ constraint_manager2::add_constraint_internal (equiv_class2_id lhs_id,
     }
 }
 
-/* Look for SVAL within the equivalence classes of this constraint_manager2;
+/* Look for SVAL within the equivalence classes of this constraint_manager;
    if found, return true, writing the id to *OUT if OUT is non-NULL,
    otherwise return false.  */
 
 bool
-constraint_manager2::get_equiv_class2_by_svalue2 (const svalue2 *sval,
-						  equiv_class2_id *out) const
+constraint_manager::get_equiv_class_by_svalue (const svalue *sval,
+					       equiv_class_id *out) const
 {
   /* TODO: should we have a map, rather than these searches?  */
   int i;
-  equiv_class2 *ec;
+  equiv_class *ec;
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     {
       int j;
-      const svalue2 *iv;
+      const svalue *iv;
       FOR_EACH_VEC_ELT (ec->m_vars, j, iv)
 	if (iv == sval)
 	  {
 	    if (out)
-	      *out = equiv_class2_id (i);
+	      *out = equiv_class_id (i);
 	    return true;
 	  }
     }
   return false;
 }
 
-/* Ensure that SVAL has an equivalence class within this constraint_manager2;
+/* Ensure that SVAL has an equivalence class within this constraint_manager;
    return the ID of the class.  */
 
-equiv_class2_id
-constraint_manager2::get_or_add_equiv_class2 (const svalue2 *sval)
+equiv_class_id
+constraint_manager::get_or_add_equiv_class (const svalue *sval)
 {
-  equiv_class2_id result (-1);
+  equiv_class_id result (-1);
 
-  gcc_assert (sval->get_kind () != svalue2::SK_UNKNOWN);
+  gcc_assert (sval->get_kind () != svalue::SK_UNKNOWN);
 
   /* Convert all NULL pointers to (void *) to avoid state explosions
      involving all of the various (foo *)NULL vs (bar *)NULL.  */
@@ -1222,18 +1222,18 @@ constraint_manager2::get_or_add_equiv_class2 (const svalue2 *sval)
   if (POINTER_TYPE_P (sval->get_type ()))
     if (tree cst = sval->maybe_get_constant ())
       if (zerop (cst))
-	sval = m_mgr->get_or_create_constant_svalue2 (null_pointer_node);
+	sval = m_mgr->get_or_create_constant_svalue (null_pointer_node);
 #endif
 
-  /* Try svalue2 match.  */
-  if (get_equiv_class2_by_svalue2 (sval, &result))
+  /* Try svalue match.  */
+  if (get_equiv_class_by_svalue (sval, &result))
     return result;
 
   /* Try equality of constants.  */
   if (tree cst = sval->maybe_get_constant ())
     {
       int i;
-      equiv_class2 *ec;
+      equiv_class *ec;
       FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
 	if (ec->m_constant
 	    && types_compatible_p (TREE_TYPE (cst),
@@ -1244,18 +1244,18 @@ constraint_manager2::get_or_add_equiv_class2 (const svalue2 *sval)
 	    if (eq == boolean_true_node)
 	      {
 		ec->add (sval);
-		return equiv_class2_id (i);
+		return equiv_class_id (i);
 	      }
 	  }
     }
 
 
   /* Not found.  */
-  equiv_class2 *new_ec = new equiv_class2 ();
+  equiv_class *new_ec = new equiv_class ();
   new_ec->add (sval);
   m_equiv_classes.safe_push (new_ec);
 
-  equiv_class2_id new_id (m_equiv_classes.length () - 1);
+  equiv_class_id new_id (m_equiv_classes.length () - 1);
 
   if (sval->maybe_get_constant ())
     {
@@ -1263,10 +1263,10 @@ constraint_manager2::get_or_add_equiv_class2 (const svalue2 *sval)
 	 to other constants we may have (so that we accumulate the transitive
 	 closure of all constraints on constants as the constants are
 	 added).  */
-      for (equiv_class2_id other_id (0); other_id.m_idx < new_id.m_idx;
+      for (equiv_class_id other_id (0); other_id.m_idx < new_id.m_idx;
 	   other_id.m_idx++)
 	{
-	  const equiv_class2 &other_ec = other_id.get_obj (*this);
+	  const equiv_class &other_ec = other_id.get_obj (*this);
 	  if (other_ec.m_constant
 	      && types_compatible_p (TREE_TYPE (new_ec->m_constant),
 				     TREE_TYPE (other_ec.m_constant)))
@@ -1279,13 +1279,13 @@ constraint_manager2::get_or_add_equiv_class2 (const svalue2 *sval)
 		= fold_binary (LT_EXPR, boolean_type_node,
 			       new_ec->m_constant, other_ec.m_constant);
 	      if (lt == boolean_true_node)
-		add_constraint_internal (new_id, CONSTRAINT2_LT, other_id);
+		add_constraint_internal (new_id, CONSTRAINT_LT, other_id);
 	      else if (lt == boolean_false_node)
-		add_constraint_internal (other_id, CONSTRAINT2_LT, new_id);
+		add_constraint_internal (other_id, CONSTRAINT_LT, new_id);
 	      /* Refresh new_id, in case ECs were merged.  SVAL should always
 		 be present by now, so this should never lead to a
 		 recursion.  */
-	      new_id = get_or_add_equiv_class2 (sval);
+	      new_id = get_or_add_equiv_class (sval);
 	    }
 	}
     }
@@ -1296,9 +1296,9 @@ constraint_manager2::get_or_add_equiv_class2 (const svalue2 *sval)
 /* Evaluate the condition LHS_EC OP RHS_EC.  */
 
 tristate
-constraint_manager2::eval_condition (equiv_class2_id lhs_ec,
+constraint_manager::eval_condition (equiv_class_id lhs_ec,
 				    enum tree_code op,
-				    equiv_class2_id rhs_ec) const
+				    equiv_class_id rhs_ec) const
 {
   if (lhs_ec == rhs_ec)
     {
@@ -1331,7 +1331,7 @@ constraint_manager2::eval_condition (equiv_class2_id lhs_ec,
   enum tree_code swapped_op = swap_tree_comparison (op);
 
   int i;
-  constraint2 *c;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     {
       if (c->m_lhs == lhs_ec
@@ -1356,13 +1356,13 @@ constraint_manager2::eval_condition (equiv_class2_id lhs_ec,
   return tristate (tristate::TS_UNKNOWN);
 }
 
-range2
-constraint_manager2::get_ec_bounds (equiv_class2_id ec_id) const
+range
+constraint_manager::get_ec_bounds (equiv_class_id ec_id) const
 {
-  range2 result;
+  range result;
 
   int i;
-  constraint2 *c;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     {
       if (c->m_lhs == ec_id)
@@ -1372,17 +1372,17 @@ constraint_manager2::get_ec_bounds (equiv_class2_id ec_id) const
 	      {
 	      default:
 		gcc_unreachable ();
-	      case CONSTRAINT2_NE:
+	      case CONSTRAINT_NE:
 		continue;
 
-	      case CONSTRAINT2_LT:
+	      case CONSTRAINT_LT:
 		/* We have "EC_ID < OTHER_CST".  */
-		result.m_upper_bound = bound2 (other_cst, false);
+		result.m_upper_bound = bound (other_cst, false);
 		break;
 
-	      case CONSTRAINT2_LE:
+	      case CONSTRAINT_LE:
 		/* We have "EC_ID <= OTHER_CST".  */
-		result.m_upper_bound = bound2 (other_cst, true);
+		result.m_upper_bound = bound (other_cst, true);
 		break;
 	      }
 	}
@@ -1393,19 +1393,19 @@ constraint_manager2::get_ec_bounds (equiv_class2_id ec_id) const
 	      {
 	      default:
 		gcc_unreachable ();
-	      case CONSTRAINT2_NE:
+	      case CONSTRAINT_NE:
 		continue;
 
-	      case CONSTRAINT2_LT:
+	      case CONSTRAINT_LT:
 		/* We have "OTHER_CST < EC_ID"
 		   i.e. "EC_ID > OTHER_CST".  */
-		result.m_lower_bound = bound2 (other_cst, false);
+		result.m_lower_bound = bound (other_cst, false);
 		break;
 
-	      case CONSTRAINT2_LE:
+	      case CONSTRAINT_LE:
 		/* We have "OTHER_CST <= EC_ID"
 		   i.e. "EC_ID >= OTHER_CST".  */
-		result.m_lower_bound = bound2 (other_cst, true);
+		result.m_lower_bound = bound (other_cst, true);
 		break;
 	      }
 	}
@@ -1416,10 +1416,10 @@ constraint_manager2::get_ec_bounds (equiv_class2_id ec_id) const
 
 
 /* Evaluate the condition LHS_EC OP RHS_CONST, avoiding the creation
-   of equiv_class2 instances.  */
+   of equiv_class instances.  */
 
 tristate
-constraint_manager2::eval_condition (equiv_class2_id lhs_ec,
+constraint_manager::eval_condition (equiv_class_id lhs_ec,
 				     enum tree_code op,
 				     tree rhs_const) const
 {
@@ -1438,10 +1438,10 @@ constraint_manager2::eval_condition (equiv_class2_id lhs_ec,
        ptr == (foo *)0
      to be false.  */
   int i;
-  constraint2 *c;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     {
-      if (c->m_op == CONSTRAINT2_NE)
+      if (c->m_op == CONSTRAINT_NE)
 	{
 	  if (c->m_lhs == lhs_ec)
 	    {
@@ -1480,27 +1480,27 @@ constraint_manager2::eval_condition (equiv_class2_id lhs_ec,
 	}
     }
   /* Look at existing bounds on LHS_EC.  */
-  range2 lhs_bounds = get_ec_bounds (lhs_ec);
+  range lhs_bounds = get_ec_bounds (lhs_ec);
   return lhs_bounds.eval_condition (op, rhs_const);
 }
 
 // FIXME:
 /* Evaluate the condition LHS OP RHS, avoiding the creation
-   of equiv_class2 instances.  */
+   of equiv_class instances.  */
 
 tristate
-constraint_manager2::eval_condition (const svalue2 *lhs,
+constraint_manager::eval_condition (const svalue *lhs,
 				     enum tree_code op,
-				     const svalue2 *rhs) const
+				     const svalue *rhs) const
 {
   lhs = lhs->unwrap_any_unmergeable ();
   rhs = rhs->unwrap_any_unmergeable ();
 
   /* Nothing can be known about unknown or poisoned values.  */
-  if (lhs->get_kind () == svalue2::SK_UNKNOWN
-      || lhs->get_kind () == svalue2::SK_POISONED
-      || rhs->get_kind () == svalue2::SK_UNKNOWN
-      || rhs->get_kind () == svalue2::SK_POISONED)
+  if (lhs->get_kind () == svalue::SK_UNKNOWN
+      || lhs->get_kind () == svalue::SK_POISONED
+      || rhs->get_kind () == svalue::SK_UNKNOWN
+      || rhs->get_kind () == svalue::SK_POISONED)
     return tristate (tristate::TS_UNKNOWN);
 
   if (lhs == rhs
@@ -1523,10 +1523,10 @@ constraint_manager2::eval_condition (const svalue2 *lhs,
 	}
     }
 
-  equiv_class2_id lhs_ec (-1);
-  equiv_class2_id rhs_ec (-1);
-  get_equiv_class2_by_svalue2 (lhs, &lhs_ec);
-  get_equiv_class2_by_svalue2 (rhs, &rhs_ec);
+  equiv_class_id lhs_ec (-1);
+  equiv_class_id rhs_ec (-1);
+  get_equiv_class_by_svalue (lhs, &lhs_ec);
+  get_equiv_class_by_svalue (rhs, &rhs_ec);
   if (!lhs_ec.null_p () && !rhs_ec.null_p ())
     {
       tristate result_for_ecs
@@ -1571,23 +1571,23 @@ constraint_manager2::eval_condition (const svalue2 *lhs,
   return tristate (tristate::TS_UNKNOWN);
 }
 
-/* Delete any information about svalue2_id instances identified by P.
+/* Delete any information about svalues identified by P.
    Such instances are removed from equivalence classes, and any
    redundant ECs and constraints are also removed.
    Accumulate stats into STATS.  */
 
 template <typename PurgeCriteria>
 void
-constraint_manager2::purge (const PurgeCriteria &p, purge_stats2 *stats)
+constraint_manager::purge (const PurgeCriteria &p, purge_stats *stats)
 {
-  /* Delete any svalue2_ids identified by P within the various equivalence
+  /* Delete any svalues identified by P within the various equivalence
      classes.  */
   for (unsigned ec_idx = 0; ec_idx < m_equiv_classes.length (); )
     {
-      equiv_class2 *ec = m_equiv_classes[ec_idx];
+      equiv_class *ec = m_equiv_classes[ec_idx];
 
       int i;
-      const svalue2 *sval;
+      const svalue *sval;
       bool delete_ec = false;
       FOR_EACH_VEC_ELT (ec->m_vars, i, sval)
 	{
@@ -1611,7 +1611,7 @@ constraint_manager2::purge (const PurgeCriteria &p, purge_stats2 *stats)
 	  /* Update the constraints, potentially removing some.  */
 	  for (unsigned con_idx = 0; con_idx < m_constraints.length (); )
 	    {
-	      constraint2 *c = &m_constraints[con_idx];
+	      constraint *c = &m_constraints[con_idx];
 
 	      /* Remove constraints that refer to the deleted EC.  */
 	      if (c->m_lhs == ec_idx
@@ -1639,7 +1639,7 @@ constraint_manager2::purge (const PurgeCriteria &p, purge_stats2 *stats)
   /* Now delete any constraints that are purely between constants.  */
   for (unsigned con_idx = 0; con_idx < m_constraints.length (); )
     {
-      constraint2 *c = &m_constraints[con_idx];
+      constraint *c = &m_constraints[con_idx];
       if (m_equiv_classes[c->m_lhs.m_idx]->m_vars.length () == 0
 	  && m_equiv_classes[c->m_rhs.m_idx]->m_vars.length () == 0)
 	{
@@ -1657,15 +1657,15 @@ constraint_manager2::purge (const PurgeCriteria &p, purge_stats2 *stats)
      referenced by any constraints.  */
   for (unsigned ec_idx = 0; ec_idx < m_equiv_classes.length (); )
     {
-      equiv_class2 *ec = m_equiv_classes[ec_idx];
+      equiv_class *ec = m_equiv_classes[ec_idx];
       if (ec->m_vars.length () == 0)
 	{
-	  equiv_class2_id ec_id (ec_idx);
+	  equiv_class_id ec_id (ec_idx);
 	  bool has_constraint = false;
 	  for (unsigned con_idx = 0; con_idx < m_constraints.length ();
 	       con_idx++)
 	    {
-	      constraint2 *c = &m_constraints[con_idx];
+	      constraint *c = &m_constraints[con_idx];
 	      if (c->m_lhs == ec_id
 		  || c->m_rhs == ec_id)
 		{
@@ -1685,7 +1685,7 @@ constraint_manager2::purge (const PurgeCriteria &p, purge_stats2 *stats)
 	      for (unsigned con_idx = 0; con_idx < m_constraints.length ();
 		   con_idx++)
 		{
-		  constraint2 *c = &m_constraints[con_idx];
+		  constraint *c = &m_constraints[con_idx];
 		  c->m_lhs.update_for_removal (ec_idx);
 		  c->m_rhs.update_for_removal (ec_idx);
 		}
@@ -1703,46 +1703,46 @@ constraint_manager2::purge (const PurgeCriteria &p, purge_stats2 *stats)
 class dead_svalue_purger
 {
 public:
-  dead_svalue_purger (const hash_set<const svalue2 *> &live_svalues,
-		      const region_model2 *model)
+  dead_svalue_purger (const hash_set<const svalue *> &live_svalues,
+		      const region_model *model)
   : m_live_svalues (live_svalues), m_model (model)
   {
   }
 
-  bool should_purge_p (const svalue2 *sval) const
+  bool should_purge_p (const svalue *sval) const
   {
     return !sval->live_p (m_live_svalues, m_model);
   }
 
 private:
-  const hash_set<const svalue2 *> &m_live_svalues;
-  const region_model2 *m_model;
+  const hash_set<const svalue *> &m_live_svalues;
+  const region_model *m_model;
 };
 
 /* Purge dead svalues from equivalence classes and update constraints
    accordingly.  */
 
 void
-constraint_manager2::
-on_liveness_change (const hash_set<const svalue2 *> &live_svalues,
-		    const region_model2 *model)
+constraint_manager::
+on_liveness_change (const hash_set<const svalue *> &live_svalues,
+		    const region_model *model)
 {
   dead_svalue_purger p (live_svalues, model);
   purge (p, NULL);
 }
 
-/* Comparator for use by constraint_manager2::canonicalize.
-   Sort a pair of equiv_class2 instances, using the representative
-   svalue2_id as a sort key.  */
+/* Comparator for use by constraint_manager::canonicalize.
+   Sort a pair of equiv_class instances, using the representative
+   svalue as a sort key.  */
 
 static int
-equiv_class2_cmp (const void *p1, const void *p2)
+equiv_class_cmp (const void *p1, const void *p2)
 {
-  const equiv_class2 *ec1 = *(const equiv_class2 * const *)p1;
-  const equiv_class2 *ec2 = *(const equiv_class2 * const *)p2;
+  const equiv_class *ec1 = *(const equiv_class * const *)p1;
+  const equiv_class *ec2 = *(const equiv_class * const *)p2;
 
-  const svalue2 *rep1 = ec1->get_representative ();
-  const svalue2 *rep2 = ec2->get_representative ();
+  const svalue *rep1 = ec1->get_representative ();
+  const svalue *rep2 = ec2->get_representative ();
 
   gcc_assert (rep1);
   gcc_assert (rep2);
@@ -1754,14 +1754,14 @@ equiv_class2_cmp (const void *p1, const void *p2)
   return 0;
 }
 
-/* Comparator for use by constraint_manager2::canonicalize.
+/* Comparator for use by constraint_manager::canonicalize.
    Sort a pair of constraint instances.  */
 
 static int
 constraint_cmp (const void *p1, const void *p2)
 {
-  const constraint2 *c1 = (const constraint2 *)p1;
-  const constraint2 *c2 = (const constraint2 *)p2;
+  const constraint *c1 = (const constraint *)p1;
+  const constraint *c2 = (const constraint *)p2;
   int lhs_cmp = c1->m_lhs.as_int () - c2->m_lhs.as_int ();
   if (lhs_cmp)
     return lhs_cmp;
@@ -1772,15 +1772,15 @@ constraint_cmp (const void *p1, const void *p2)
 }
 
 /* Purge redundant equivalence classes and constraints, and reorder them
-   within this constraint_manager2 into a canonical order, to increase the
+   within this constraint_manager into a canonical order, to increase the
    chances of finding equality with another instance.  */
 
 void
-constraint_manager2::canonicalize ()
+constraint_manager::canonicalize ()
 {
-  /* First, sort svalue2s within the ECs.  */
+  /* First, sort svalues within the ECs.  */
   unsigned i;
-  equiv_class2 *ec;
+  equiv_class *ec;
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     ec->canonicalize ();
 
@@ -1788,22 +1788,22 @@ constraint_manager2::canonicalize ()
      thus implicit.  But does this break transitivity?  */
 
   /* We will be purging and reordering ECs.
-     We will need to remap the equiv_class2_ids in the constraints,
+     We will need to remap the equiv_class_ids in the constraints,
      so we need to store the original index of each EC.
-     Build a lookup table, mapping from the representative svalue2
-     to the original equiv_class2_id of that svalue2.  */
-  hash_map<const svalue2 *, equiv_class2_id> original_ec_id;
+     Build a lookup table, mapping from the representative svalue
+     to the original equiv_class_id of that svalue.  */
+  hash_map<const svalue *, equiv_class_id> original_ec_id;
   const unsigned orig_num_equiv_classes = m_equiv_classes.length ();
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     {
-      const svalue2 *rep = ec->get_representative ();
+      const svalue *rep = ec->get_representative ();
       gcc_assert (rep);
       original_ec_id.put (rep, i);
     }
 
   /* Find ECs used by constraints.  */
-  hash_set<const equiv_class2 *> used_ecs;
-  constraint2 *c;
+  hash_set<const equiv_class *> used_ecs;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     {
       used_ecs.add (m_equiv_classes[c->m_lhs.as_int ()]);
@@ -1811,14 +1811,14 @@ constraint_manager2::canonicalize ()
     }
 
   /* Purge unused ECs: those that aren't used by constraints and
-     that effectively have only one svalue2 (either in m_constant
+     that effectively have only one svalue (either in m_constant
      or in m_vars).  */
   {
     /* "unordered remove if" from a vec.  */
     unsigned i = 0;
     while (i < m_equiv_classes.length ())
       {
-	equiv_class2 *ec = m_equiv_classes[i];
+	equiv_class *ec = m_equiv_classes[i];
 	if (!used_ecs.contains (ec)
 	    && ((ec->m_vars.length () < 2 && ec->m_constant == NULL_TREE)
 		|| (ec->m_vars.length () == 0)))
@@ -1832,13 +1832,13 @@ constraint_manager2::canonicalize ()
   }
 
   /* Next, sort the surviving ECs into a canonical order.  */
-  m_equiv_classes.qsort (equiv_class2_cmp);
+  m_equiv_classes.qsort (equiv_class_cmp);
 
   /* Populate ec_id_map based on the old vs new EC ids.  */
-  one_way_id_map<equiv_class2_id> ec_id_map (orig_num_equiv_classes);
+  one_way_id_map<equiv_class_id> ec_id_map (orig_num_equiv_classes);
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     {
-      const svalue2 *rep = ec->get_representative ();
+      const svalue *rep = ec->get_representative ();
       gcc_assert (rep);
       ec_id_map.put (*original_ec_id.get (rep), i);
     }
@@ -1854,43 +1854,43 @@ constraint_manager2::canonicalize ()
   m_constraints.qsort (constraint_cmp);
 }
 
-/* A concrete subclass of constraint_manager2 for use when
-   merging two constraint_manager2 into a third constraint_manager2,
-   each of which has its own region_model2.
-   Calls are delegated to the constraint_manager2 for the merged model,
-   and thus affect its region_model2.  */
+/* A concrete subclass of constraint_manager for use when
+   merging two constraint_manager into a third constraint_manager,
+   each of which has its own region_model.
+   Calls are delegated to the constraint_manager for the merged model,
+   and thus affect its region_model.  */
 #if 0
-class cleaned_constraint_manager2 : public constraint_manager2
+class cleaned_constraint_manager : public constraint_manager
 {
 public:
-  cleaned_constraint_manager2 (constraint_manager2 *merged)
-  : constraint_manager2 (merged->m_mgr),
+  cleaned_constraint_manager (constraint_manager *merged)
+  : constraint_manager (merged->m_mgr),
     m_merged (merged) {}
 
 #if 0
-  constraint_manager2 *clone (region_model2 *) const FINAL OVERRIDE
+  constraint_manager *clone (region_model *) const FINAL OVERRIDE
   {
     gcc_unreachable ();
   }
 #endif
 private:
-  constraint_manager2 *m_merged;
+  constraint_manager *m_merged;
 };
 #endif
-/* Concrete subclass of fact_visitor for use by constraint_manager2::merge.
+/* Concrete subclass of fact_visitor for use by constraint_manager::merge.
    For every fact in CM_A, see if it is also true in *CM_B.  Add such
    facts to *OUT.  */
 
-class merger2_fact_visitor : public fact2_visitor
+class merger_fact_visitor : public fact_visitor
 {
 public:
-  merger2_fact_visitor (constraint_manager2 *cm_b,
-			constraint_manager2 *out,
-			const model2_merger &merger)
+  merger_fact_visitor (constraint_manager *cm_b,
+			constraint_manager *out,
+			const model_merger &merger)
   : m_cm_b (cm_b), m_out (out), m_merger (merger)
   {}
 
-  void on_fact (const svalue2 *lhs, enum tree_code code, const svalue2 *rhs)
+  void on_fact (const svalue *lhs, enum tree_code code, const svalue *rhs)
     FINAL OVERRIDE
   {
     /* If we merged (M BINOP X) with M
@@ -1901,12 +1901,12 @@ public:
     // TODO: we need to fix eval_condition for this to work.
 #if ITERATED_BINOPS
     unsigned i;
-    const binop_svalue2 *binop;
+    const binop_svalue *binop;
     FOR_EACH_VEC_ELT (m_merger.m_iterated_binops, i, binop)
       {
 	if (binop->get_arg0 () == lhs)
 	  {
-	    region_model2_manager *mgr = m_merger.get_manager ();
+	    region_model_manager *mgr = m_merger.get_manager ();
 	    rhs = mgr->get_or_create_binop (rhs->get_type (),
 					    binop->get_op (),
 					    rhs, binop->get_arg1 ());
@@ -1917,8 +1917,8 @@ public:
     /* Special-case for widening.  */
     /* FIXME: should only do this if LHS isn't mentioned anywhere in
        m_cm_b's model, rather than just in m_cb_b?  */
-    if (lhs->get_kind () == svalue2::SK_WIDENING)
-      if (!m_cm_b->get_equiv_class2_by_svalue2 (lhs, NULL))
+    if (lhs->get_kind () == svalue::SK_WIDENING)
+      if (!m_cm_b->get_equiv_class_by_svalue (lhs, NULL))
 	{
 	  /* LHS isn't constrained within m_cm_b.  */
 	  /* FIXME: for now, treat it as "unmentioned".  */
@@ -1935,116 +1935,56 @@ public:
   }
 
 private:
-  constraint_manager2 *m_cm_b;
-  constraint_manager2 *m_out;
-  const model2_merger &m_merger;
+  constraint_manager *m_cm_b;
+  constraint_manager *m_out;
+  const model_merger &m_merger;
 };
 
 // FIXME
 /* Use MERGER to merge CM_A and CM_B into *OUT.
-   If one thinks of a constraint_manager2 as a subset of N-dimensional
+   If one thinks of a constraint_manager as a subset of N-dimensional
    space, this takes the union of the points of CM_A and CM_B, and
    expresses that into *OUT.  Alternatively, it can be thought of
    as the intersection of the constraints.  */
 
 void
-constraint_manager2::merge (const constraint_manager2 &cm_a,
-			    const constraint_manager2 &cm_b,
-			    constraint_manager2 *out,
-			    const model2_merger &merger)
+constraint_manager::merge (const constraint_manager &cm_a,
+			    const constraint_manager &cm_b,
+			    constraint_manager *out,
+			    const model_merger &merger)
 {
   /* FIXME: work with a copy, since eval_condition can mutate a cm.  */
-  constraint_manager2 copy_cm_a (cm_a);
-  constraint_manager2 copy_cm_b (cm_b);
+  constraint_manager copy_cm_a (cm_a);
+  constraint_manager copy_cm_b (cm_b);
 
   /* Merge the equivalence classes and constraints.
      The easiest way to do this seems to be to enumerate all of the facts
      in cm_a, see which are also true in cm_b,
      and add those to *OUT.  */
-  merger2_fact_visitor v (&copy_cm_b, out, merger);
+  merger_fact_visitor v (&copy_cm_b, out, merger);
   copy_cm_a.for_each_fact (&v);
 
   /* FIXME and the other way around, since things could be implicit in one
      and explicit in the other?  */
 }
 
-/* A subroutine of constraint_manager2::merge.
-   Use MAP_SVAL_TO_M to map equivalence classes and constraints from
-   SM_IN to *OUT.  Purge any non-constant svalue2 *that don't appear
-   in the result of MAP_SVAL_TO_M, purging any ECs and their constraints
-   that become empty as a result.  Potentially create svalue2s in
-   the merged region_model2 for constants that weren't already in use there.  */
-#if 0
-void
-constraint_manager2::
-clean_merger_input (const constraint_manager2 &cm_in,
-		    const one_way_svalue2_id_map &map_sval_to_m,
-		    constraint_manager2 *out)
-{
-  one_way_id_map<equiv_class2_id> map_ec_to_m
-    (cm_in.m_equiv_classes.length ());
-  unsigned ec_idx;
-  equiv_class2 *ec;
-  FOR_EACH_VEC_ELT (cm_in.m_equiv_classes, ec_idx, ec)
-    {
-      equiv_class2 cleaned_ec;
-      if (tree cst = ec->get_any_constant ())
-	{
-	  cleaned_ec.m_constant = cst;
-	  /* Lazily create the constant in the out region_model2.  */
-	  cleaned_ec.m_cst_sval = out->get_sval_for_constant (cst);
-	}
-      unsigned var_idx;
-      const svalue2 **var_in_sval;
-      FOR_EACH_VEC_ELT (ec->m_vars, var_idx, var_in_sval)
-	{
-	  const svalue2 *var_m_sval
-	    = map_sval_to_m.get_dst_for_src (*var_in_sval);
-	  if (!var_m_sval.null_p ())
-	    cleaned_ec.m_vars.safe_push (var_m_sval);
-	}
-      if (cleaned_ec.get_any_constant () || !cleaned_ec.m_vars.is_empty ())
-	{
-	  map_ec_to_m.put (ec_idx, out->m_equiv_classes.length ());
-	  out->m_equiv_classes.safe_push (new equiv_class2 (cleaned_ec));
-	}
-    }
-
-  /* Write out to *OUT any constraints for which both svales survived
-     cleaning, using the new EC IDs.  */
-  unsigned con_idx;
-  constraint2 *c;
-  FOR_EACH_VEC_ELT (cm_in.m_constraints, con_idx, c)
-    {
-      equiv_class2_id new_lhs = map_ec_to_m.get_dst_for_src (c->m_lhs);
-      if (new_lhs.null_p ())
-	continue;
-      equiv_class2_id new_rhs = map_ec_to_m.get_dst_for_src (c->m_rhs);
-      if (new_rhs.null_p ())
-	continue;
-      out->m_constraints.safe_push (constraint (new_lhs,
-						c->m_op,
-						new_rhs));
-    }
-}
-#endif
 /* Call VISITOR's on_fact vfunc repeatedly to express the various
    equivalence classes and constraints.
-   This is used by constraint_manager2::merge to find the common
-   facts between two input constraint_manager2s.  */
+   This is used by constraint_manager::merge to find the common
+   facts between two input constraint_managers.  */
 
 void
-constraint_manager2::for_each_fact (fact2_visitor *visitor) const
+constraint_manager::for_each_fact (fact_visitor *visitor) const
 {
   /* First, call EQ_EXPR within the various equivalence classes.  */
   unsigned ec_idx;
-  equiv_class2 *ec;
+  equiv_class *ec;
   FOR_EACH_VEC_ELT (m_equiv_classes, ec_idx, ec)
     {
       if (ec->m_cst_sval)
 	{
 	  unsigned i;
-	  const svalue2 *sval;
+	  const svalue *sval;
 	  FOR_EACH_VEC_ELT (ec->m_vars, i, sval)
 	    visitor->on_fact (ec->m_cst_sval, EQ_EXPR, sval);
 	}
@@ -2055,12 +1995,12 @@ constraint_manager2::for_each_fact (fact2_visitor *visitor) const
 
   /* Now, express the various constraints.  */
   unsigned con_idx;
-  constraint2 *c;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, con_idx, c)
     {
-      const equiv_class2 &ec_lhs = c->m_lhs.get_obj (*this);
-      const equiv_class2 &ec_rhs = c->m_rhs.get_obj (*this);
-      enum tree_code code = constraint2_tree_code (c->m_op);
+      const equiv_class &ec_lhs = c->m_lhs.get_obj (*this);
+      const equiv_class &ec_rhs = c->m_rhs.get_obj (*this);
+      enum tree_code code = constraint_tree_code (c->m_op);
 
       if (ec_lhs.m_cst_sval)
 	{
@@ -2082,7 +2022,7 @@ constraint_manager2::for_each_fact (fact2_visitor *visitor) const
 /* Assert that this object is valid.  */
 
 void
-constraint_manager2::validate () const
+constraint_manager::validate () const
 {
   /* Skip this in a release build.  */
 #if !CHECKING_P
@@ -2090,13 +2030,13 @@ constraint_manager2::validate () const
 #endif
 
   int i;
-  equiv_class2 *ec;
+  equiv_class *ec;
   FOR_EACH_VEC_ELT (m_equiv_classes, i, ec)
     {
       gcc_assert (ec);
 
       int j;
-      const svalue2 *sval;
+      const svalue *sval;
       FOR_EACH_VEC_ELT (ec->m_vars, j, sval)
 	gcc_assert (sval);
       if (ec->m_constant)
@@ -2110,7 +2050,7 @@ constraint_manager2::validate () const
 #endif
     }
 
-  constraint2 *c;
+  constraint *c;
   FOR_EACH_VEC_ELT (m_constraints, i, c)
     {
       gcc_assert (!c->m_lhs.null_p ());
@@ -2124,13 +2064,12 @@ constraint_manager2::validate () const
 
 namespace selftest {
 
-/* Various constraint_manager2 selftests.
-   These have to be written in terms of a region_model2, since
-   the latter is responsible for managing svalue2 and svalue2_id
-   instances.  */
+/* Various constraint_manager selftests.
+   These have to be written in terms of a region_model, since
+   the latter is responsible for managing svalue instances.  */
 
-/* Verify that setting and getting simple conditions within a region_model2
-   work (thus exercising the underlying constraint_manager2).  */
+/* Verify that setting and getting simple conditions within a region_model
+   work (thus exercising the underlying constraint_manager).  */
 
 static void
 test_constraint_conditions ()
@@ -2144,278 +2083,278 @@ test_constraint_conditions ()
 
   /* Self-comparisons.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    ASSERT_CONDITION_TRUE2 (model, x, EQ_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, x, LE_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, x, GE_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, x, NE_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, x, LT_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, x, GT_EXPR, x);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    ASSERT_CONDITION_TRUE (model, x, EQ_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, x, LE_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, x, GE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, x, NE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, x, LT_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, x, GT_EXPR, x);
   }
 
   /* Adding self-equality shouldn't add equiv classes.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, x);
     ADD_SAT_CONSTRAINT (model, int_42, EQ_EXPR, int_42);
     /* ...even when done directly via svalues: */
-    const svalue2 *sval_int_42 = model.get_rvalue (int_42, NULL);
-    bool sat = model.get_constraints2 ()->add_constraint (sval_int_42,
+    const svalue *sval_int_42 = model.get_rvalue (int_42, NULL);
+    bool sat = model.get_constraints ()->add_constraint (sval_int_42,
 							  EQ_EXPR,
 							  sval_int_42);
     ASSERT_TRUE (sat);
-    ASSERT_EQ (model.get_constraints2 ()->m_equiv_classes.length (), 0);
+    ASSERT_EQ (model.get_constraints ()->m_equiv_classes.length (), 0);
   }
 
   /* x == y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, y);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, y);
 
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, y);
 
-    ASSERT_CONDITION_TRUE2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, LE_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, GE_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, NE_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, LT_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, GT_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, LE_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, GE_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, NE_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, LT_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, GT_EXPR, y);
 
     /* Swapped operands.  */
-    ASSERT_CONDITION_TRUE2 (model, y, EQ_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, LE_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, GE_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, NE_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, LT_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, GT_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, EQ_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, LE_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, GE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, NE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, LT_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, GT_EXPR, x);
 
     /* Comparison with other var.  */
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, NE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LT_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GT_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, LE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, NE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, LT_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, GT_EXPR, z);
   }
 
   /* x == y, then y == z  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, y);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, y);
 
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, y);
     ADD_SAT_CONSTRAINT (model, y, EQ_EXPR, z);
 
-    ASSERT_CONDITION_TRUE2 (model, x, EQ_EXPR, z);
-    ASSERT_CONDITION_TRUE2 (model, x, LE_EXPR, z);
-    ASSERT_CONDITION_TRUE2 (model, x, GE_EXPR, z);
-    ASSERT_CONDITION_FALSE2 (model, x, NE_EXPR, z);
-    ASSERT_CONDITION_FALSE2 (model, x, LT_EXPR, z);
-    ASSERT_CONDITION_FALSE2 (model, x, GT_EXPR, z);
+    ASSERT_CONDITION_TRUE (model, x, EQ_EXPR, z);
+    ASSERT_CONDITION_TRUE (model, x, LE_EXPR, z);
+    ASSERT_CONDITION_TRUE (model, x, GE_EXPR, z);
+    ASSERT_CONDITION_FALSE (model, x, NE_EXPR, z);
+    ASSERT_CONDITION_FALSE (model, x, LT_EXPR, z);
+    ASSERT_CONDITION_FALSE (model, x, GT_EXPR, z);
   }
 
   /* x != y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
 
     ADD_SAT_CONSTRAINT (model, x, NE_EXPR, y);
 
-    ASSERT_CONDITION_TRUE2 (model, x, NE_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LE_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LT_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GT_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, NE_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, LE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, LT_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, GT_EXPR, y);
 
     /* Swapped operands.  */
-    ASSERT_CONDITION_TRUE2 (model, y, NE_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, EQ_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, LE_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, GE_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, LT_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, GT_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, NE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, EQ_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, LE_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, GE_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, LT_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, GT_EXPR, x);
 
     /* Comparison with other var.  */
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, NE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LT_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GT_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, LE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, NE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, LT_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, GT_EXPR, z);
   }
 
   /* x < y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
 
     ADD_SAT_CONSTRAINT (model, x, LT_EXPR, y);
 
-    ASSERT_CONDITION_TRUE2 (model, x, LT_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, LE_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, NE_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, GT_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, GE_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, LT_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, LE_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, NE_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, GT_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, GE_EXPR, y);
 
     /* Swapped operands.  */
-    ASSERT_CONDITION_FALSE2 (model, y, LT_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, LE_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, NE_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, EQ_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, GT_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, GE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, LT_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, LE_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, NE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, EQ_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, GT_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, GE_EXPR, x);
   }
 
   /* x <= y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
 
     ADD_SAT_CONSTRAINT (model, x, LE_EXPR, y);
 
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LT_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, LE_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, NE_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, GT_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, LT_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, LE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, NE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, GT_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, y);
 
     /* Swapped operands.  */
-    ASSERT_CONDITION_FALSE2 (model, y, LT_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, LE_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, NE_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, EQ_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, GT_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, GE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, LT_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, LE_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, NE_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, EQ_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, GT_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, GE_EXPR, x);
   }
 
   /* x > y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
 
     ADD_SAT_CONSTRAINT (model, x, GT_EXPR, y);
 
-    ASSERT_CONDITION_TRUE2 (model, x, GT_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, GE_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, NE_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, LT_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, LE_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, GT_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, GE_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, NE_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, LT_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, LE_EXPR, y);
 
     /* Swapped operands.  */
-    ASSERT_CONDITION_FALSE2 (model, y, GT_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, GE_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, NE_EXPR, x);
-    ASSERT_CONDITION_FALSE2 (model, y, EQ_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, LT_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, LE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, GT_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, GE_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, NE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, EQ_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, LT_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, LE_EXPR, x);
   }
 
   /* x >= y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
 
     ADD_SAT_CONSTRAINT (model, x, GE_EXPR, y);
 
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GT_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, GE_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, NE_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, LT_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, LE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, GT_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, GE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, NE_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, LT_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, LE_EXPR, y);
 
     /* Swapped operands.  */
-    ASSERT_CONDITION_FALSE2 (model, y, GT_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, GE_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, NE_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, EQ_EXPR, x);
-    ASSERT_CONDITION_UNKNOWN2 (model, y, LT_EXPR, x);
-    ASSERT_CONDITION_TRUE2 (model, y, LE_EXPR, x);
+    ASSERT_CONDITION_FALSE (model, y, GT_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, GE_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, NE_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, EQ_EXPR, x);
+    ASSERT_CONDITION_UNKNOWN (model, y, LT_EXPR, x);
+    ASSERT_CONDITION_TRUE (model, y, LE_EXPR, x);
   }
 
   // TODO: implied orderings
 
   /* Constants.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    ASSERT_CONDITION_FALSE2 (model, int_0, EQ_EXPR, int_42);
-    ASSERT_CONDITION_TRUE2 (model, int_0, NE_EXPR, int_42);
-    ASSERT_CONDITION_TRUE2 (model, int_0, LT_EXPR, int_42);
-    ASSERT_CONDITION_TRUE2 (model, int_0, LE_EXPR, int_42);
-    ASSERT_CONDITION_FALSE2 (model, int_0, GT_EXPR, int_42);
-    ASSERT_CONDITION_FALSE2 (model, int_0, GE_EXPR, int_42);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    ASSERT_CONDITION_FALSE (model, int_0, EQ_EXPR, int_42);
+    ASSERT_CONDITION_TRUE (model, int_0, NE_EXPR, int_42);
+    ASSERT_CONDITION_TRUE (model, int_0, LT_EXPR, int_42);
+    ASSERT_CONDITION_TRUE (model, int_0, LE_EXPR, int_42);
+    ASSERT_CONDITION_FALSE (model, int_0, GT_EXPR, int_42);
+    ASSERT_CONDITION_FALSE (model, int_0, GE_EXPR, int_42);
   }
 
   /* x == 0, y == 42.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, int_0);
     ADD_SAT_CONSTRAINT (model, y, EQ_EXPR, int_42);
 
-    ASSERT_CONDITION_TRUE2 (model, x, NE_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, LE_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, GE_EXPR, y);
-    ASSERT_CONDITION_TRUE2 (model, x, LT_EXPR, y);
-    ASSERT_CONDITION_FALSE2 (model, x, GT_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, NE_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, LE_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, GE_EXPR, y);
+    ASSERT_CONDITION_TRUE (model, x, LT_EXPR, y);
+    ASSERT_CONDITION_FALSE (model, x, GT_EXPR, y);
   }
 
   /* Unsatisfiable combinations.  */
 
   /* x == y && x != y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, y);
     ADD_UNSAT_CONSTRAINT (model, x, NE_EXPR, y);
   }
 
   /* x == 0 then x == 42.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, int_0);
     ADD_UNSAT_CONSTRAINT (model, x, EQ_EXPR, int_42);
   }
 
   /* x == 0 then x != 0.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, int_0);
     ADD_UNSAT_CONSTRAINT (model, x, NE_EXPR, int_0);
   }
 
   /* x == 0 then x > 0.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, int_0);
     ADD_UNSAT_CONSTRAINT (model, x, GT_EXPR, int_0);
   }
 
   /* x != y && x == y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, NE_EXPR, y);
     ADD_UNSAT_CONSTRAINT (model, x, EQ_EXPR, y);
   }
 
   /* x <= y && x > y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, x, LE_EXPR, y);
     ADD_UNSAT_CONSTRAINT (model, x, GT_EXPR, y);
   }
@@ -2435,89 +2374,89 @@ test_transitivity ()
 
   /* a == b, then c == d, then c == b.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    ASSERT_CONDITION_UNKNOWN2 (model, a, EQ_EXPR, b);
-    ASSERT_CONDITION_UNKNOWN2 (model, b, EQ_EXPR, c);
-    ASSERT_CONDITION_UNKNOWN2 (model, c, EQ_EXPR, d);
-    ASSERT_CONDITION_UNKNOWN2 (model, a, EQ_EXPR, d);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    ASSERT_CONDITION_UNKNOWN (model, a, EQ_EXPR, b);
+    ASSERT_CONDITION_UNKNOWN (model, b, EQ_EXPR, c);
+    ASSERT_CONDITION_UNKNOWN (model, c, EQ_EXPR, d);
+    ASSERT_CONDITION_UNKNOWN (model, a, EQ_EXPR, d);
 
     ADD_SAT_CONSTRAINT (model, a, EQ_EXPR, b);
-    ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, b);
+    ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, b);
 
     ADD_SAT_CONSTRAINT (model, c, EQ_EXPR, d);
-    ASSERT_CONDITION_TRUE2 (model, c, EQ_EXPR, d);
-    ASSERT_CONDITION_UNKNOWN2 (model, a, EQ_EXPR, d);
+    ASSERT_CONDITION_TRUE (model, c, EQ_EXPR, d);
+    ASSERT_CONDITION_UNKNOWN (model, a, EQ_EXPR, d);
 
     ADD_SAT_CONSTRAINT (model, c, EQ_EXPR, b);
-    ASSERT_CONDITION_TRUE2 (model, c, EQ_EXPR, b);
-    ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, d);
+    ASSERT_CONDITION_TRUE (model, c, EQ_EXPR, b);
+    ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, d);
   }
 
   /* Transitivity: "a < b", "b < c" should imply "a < c".  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, LT_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, LT_EXPR, c);
 
-    ASSERT_CONDITION_TRUE2 (model, a, LT_EXPR, c);
-    ASSERT_CONDITION_FALSE2 (model, a, EQ_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, a, LT_EXPR, c);
+    ASSERT_CONDITION_FALSE (model, a, EQ_EXPR, c);
   }
 
   /* Transitivity: "a <= b", "b < c" should imply "a < c".  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, LE_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, LT_EXPR, c);
 
-    ASSERT_CONDITION_TRUE2 (model, a, LT_EXPR, c);
-    ASSERT_CONDITION_FALSE2 (model, a, EQ_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, a, LT_EXPR, c);
+    ASSERT_CONDITION_FALSE (model, a, EQ_EXPR, c);
   }
 
   /* Transitivity: "a <= b", "b <= c" should imply "a <= c".  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, LE_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, LE_EXPR, c);
 
-    ASSERT_CONDITION_TRUE2 (model, a, LE_EXPR, c);
-    ASSERT_CONDITION_UNKNOWN2 (model, a, EQ_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, a, LE_EXPR, c);
+    ASSERT_CONDITION_UNKNOWN (model, a, EQ_EXPR, c);
   }
 
   /* Transitivity: "a > b", "b > c" should imply "a > c".  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GT_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, GT_EXPR, c);
 
-    ASSERT_CONDITION_TRUE2 (model, a, GT_EXPR, c);
-    ASSERT_CONDITION_FALSE2 (model, a, EQ_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, a, GT_EXPR, c);
+    ASSERT_CONDITION_FALSE (model, a, EQ_EXPR, c);
   }
 
   /* Transitivity: "a >= b", "b > c" should imply " a > c".  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GE_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, GT_EXPR, c);
 
-    ASSERT_CONDITION_TRUE2 (model, a, GT_EXPR, c);
-    ASSERT_CONDITION_FALSE2 (model, a, EQ_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, a, GT_EXPR, c);
+    ASSERT_CONDITION_FALSE (model, a, EQ_EXPR, c);
   }
 
   /* Transitivity: "a >= b", "b >= c" should imply "a >= c".  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GE_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, GE_EXPR, c);
 
-    ASSERT_CONDITION_TRUE2 (model, a, GE_EXPR, c);
-    ASSERT_CONDITION_UNKNOWN2 (model, a, EQ_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, a, GE_EXPR, c);
+    ASSERT_CONDITION_UNKNOWN (model, a, EQ_EXPR, c);
   }
 
   /* Transitivity: "(a < b)", "(c < d)", "(b < c)" should
@@ -2527,36 +2466,36 @@ test_transitivity ()
      but also that:
        (a < d).  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, LT_EXPR, b);
     ADD_SAT_CONSTRAINT (model, c, LT_EXPR, d);
     ADD_SAT_CONSTRAINT (model, b, LT_EXPR, c);
 
-    ASSERT_CONDITION_TRUE2 (model, a, LT_EXPR, c);
-    ASSERT_CONDITION_TRUE2 (model, b, LT_EXPR, d);
-    ASSERT_CONDITION_TRUE2 (model, a, LT_EXPR, d);
+    ASSERT_CONDITION_TRUE (model, a, LT_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, b, LT_EXPR, d);
+    ASSERT_CONDITION_TRUE (model, a, LT_EXPR, d);
   }
 
   /* Transitivity: "a >= b", "b >= a" should imply that a == b.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GE_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, GE_EXPR, a);
 
     // TODO:
-    ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, b);
+    ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, b);
 
     /* The ECs for a and b should have merged, and any constraints removed.  */
-    ASSERT_EQ (model.get_constraints2 ()->m_equiv_classes.length (), 1);
-    ASSERT_EQ (model.get_constraints2 ()->m_constraints.length (), 0);
+    ASSERT_EQ (model.get_constraints ()->m_equiv_classes.length (), 1);
+    ASSERT_EQ (model.get_constraints ()->m_constraints.length (), 0);
   }
 
   /* Transitivity: "a >= b", "b > a" should be impossible.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GE_EXPR, b);
     ADD_UNSAT_CONSTRAINT (model, b, GT_EXPR, a);
   }
@@ -2564,20 +2503,20 @@ test_transitivity ()
   /* Transitivity: "a >= b", "b >= c", "c >= a" should imply
      that a == b == c.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GE_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, GE_EXPR, c);
     ADD_SAT_CONSTRAINT (model, c, GE_EXPR, a);
 
-    ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, c);
+    ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, c);
   }
 
   /* Transitivity: "a > b", "b > c", "c > a"
      should be impossible.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GT_EXPR, b);
     ADD_SAT_CONSTRAINT (model, b, GT_EXPR, c);
     ADD_UNSAT_CONSTRAINT (model, c, GT_EXPR, a);
@@ -2603,36 +2542,36 @@ test_constant_comparisons ()
 
   /* Given a >= 1024, then a <= 1023 should be impossible.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GE_EXPR, int_1024);
     ADD_UNSAT_CONSTRAINT (model, a, LE_EXPR, int_1023);
   }
 
   /* a > 4.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GT_EXPR, int_4);
-    ASSERT_CONDITION_TRUE2 (model, a, GT_EXPR, int_4);
-    ASSERT_CONDITION_TRUE2 (model, a, NE_EXPR, int_3);
-    ASSERT_CONDITION_UNKNOWN2 (model, a, NE_EXPR, int_5);
+    ASSERT_CONDITION_TRUE (model, a, GT_EXPR, int_4);
+    ASSERT_CONDITION_TRUE (model, a, NE_EXPR, int_3);
+    ASSERT_CONDITION_UNKNOWN (model, a, NE_EXPR, int_5);
   }
 
   /* a <= 4.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, LE_EXPR, int_4);
-    ASSERT_CONDITION_FALSE2 (model, a, GT_EXPR, int_4);
-    ASSERT_CONDITION_FALSE2 (model, a, GT_EXPR, int_5);
-    ASSERT_CONDITION_UNKNOWN2 (model, a, NE_EXPR, int_3);
+    ASSERT_CONDITION_FALSE (model, a, GT_EXPR, int_4);
+    ASSERT_CONDITION_FALSE (model, a, GT_EXPR, int_5);
+    ASSERT_CONDITION_UNKNOWN (model, a, NE_EXPR, int_3);
   }
 
   /* If "a > b" and "a == 3", then "b == 4" ought to be unsatisfiable.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, a, GT_EXPR, b);
     ADD_SAT_CONSTRAINT (model, a, EQ_EXPR, int_3);
     ADD_UNSAT_CONSTRAINT (model, b, EQ_EXPR, int_4);
@@ -2643,47 +2582,47 @@ test_constant_comparisons ()
     /* If "a <= 4" && "a > 3", then "a == 4",
        assuming a is of integral type.  */
     {
-      region_model2_manager mgr;
-      region_model2 model (&mgr);
+      region_model_manager mgr;
+      region_model model (&mgr);
       ADD_SAT_CONSTRAINT (model, a, LE_EXPR, int_4);
       ADD_SAT_CONSTRAINT (model, a, GT_EXPR, int_3);
-      ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, int_4);
+      ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, int_4);
     }
 
     /* If "a > 3" && "a <= 4", then "a == 4",
        assuming a is of integral type.  */
     {
-      region_model2_manager mgr;
-      region_model2 model (&mgr);
+      region_model_manager mgr;
+      region_model model (&mgr);
       ADD_SAT_CONSTRAINT (model, a, GT_EXPR, int_3);
       ADD_SAT_CONSTRAINT (model, a, LE_EXPR, int_4);
-      ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, int_4);
+      ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, int_4);
     }
     /* If "a > 3" && "a < 5", then "a == 4",
        assuming a is of integral type.  */
     {
-      region_model2_manager mgr;
-      region_model2 model (&mgr);
+      region_model_manager mgr;
+      region_model model (&mgr);
       ADD_SAT_CONSTRAINT (model, a, GT_EXPR, int_3);
       ADD_SAT_CONSTRAINT (model, a, LT_EXPR, int_5);
-      ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, int_4);
+      ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, int_4);
     }
     /* If "a >= 4" && "a < 5", then "a == 4",
        assuming a is of integral type.  */
     {
-      region_model2_manager mgr;
-      region_model2 model (&mgr);
+      region_model_manager mgr;
+      region_model model (&mgr);
       ADD_SAT_CONSTRAINT (model, a, GE_EXPR, int_4);
       ADD_SAT_CONSTRAINT (model, a, LT_EXPR, int_5);
-      ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, int_4);
+      ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, int_4);
     }
     /* If "a >= 4" && "a <= 4", then "a == 4".  */
     {
-      region_model2_manager mgr;
-      region_model2 model (&mgr);
+      region_model_manager mgr;
+      region_model model (&mgr);
       ADD_SAT_CONSTRAINT (model, a, GE_EXPR, int_4);
       ADD_SAT_CONSTRAINT (model, a, LE_EXPR, int_4);
-      ASSERT_CONDITION_TRUE2 (model, a, EQ_EXPR, int_4);
+      ASSERT_CONDITION_TRUE (model, a, EQ_EXPR, int_4);
     }
   }
 
@@ -2694,17 +2633,17 @@ test_constant_comparisons ()
     tree float_3 = build_real_from_int_cst (double_type_node, int_3);
     tree float_4 = build_real_from_int_cst (double_type_node, int_4);
 
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
     ADD_SAT_CONSTRAINT (model, f, GT_EXPR, float_3);
     ADD_SAT_CONSTRAINT (model, f, LE_EXPR, float_4);
-    ASSERT_CONDITION_UNKNOWN2 (model, f, EQ_EXPR, float_4);
-    ASSERT_CONDITION_UNKNOWN2 (model, f, EQ_EXPR, int_4);
+    ASSERT_CONDITION_UNKNOWN (model, f, EQ_EXPR, float_4);
+    ASSERT_CONDITION_UNKNOWN (model, f, EQ_EXPR, int_4);
   }
 }
 
 /* Verify various lower-level implementation details about
-   constraint_manager2.  */
+   constraint_manager.  */
 
 static void
 test_constraint_impl ()
@@ -2718,79 +2657,79 @@ test_constraint_impl ()
 
   /* x == y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
 
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, y);
 
     /* Assert various things about the insides of model.  */
-    constraint_manager2 *cm = model.get_constraints2 ();
+    constraint_manager *cm = model.get_constraints ();
     ASSERT_EQ (cm->m_constraints.length (), 0);
     ASSERT_EQ (cm->m_equiv_classes.length (), 1);
   }
 
   /* y <= z; x == y.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, z);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, z);
 
     ADD_SAT_CONSTRAINT (model, y, GE_EXPR, z);
-    ASSERT_CONDITION_TRUE2 (model, y, GE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, z);
+    ASSERT_CONDITION_TRUE (model, y, GE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, z);
 
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, y);
 
     /* Assert various things about the insides of model.  */
-    constraint_manager2 *cm = model.get_constraints2 ();
+    constraint_manager *cm = model.get_constraints ();
     ASSERT_EQ (cm->m_constraints.length (), 1);
     ASSERT_EQ (cm->m_equiv_classes.length (), 2);
 
     /* Ensure that we merged the constraints.  */
-    ASSERT_CONDITION_TRUE2 (model, x, GE_EXPR, z);
+    ASSERT_CONDITION_TRUE (model, x, GE_EXPR, z);
   }
 
   /* y <= z; y == x.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, EQ_EXPR, y);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, z);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    ASSERT_CONDITION_UNKNOWN (model, x, EQ_EXPR, y);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, z);
 
     ADD_SAT_CONSTRAINT (model, y, GE_EXPR, z);
-    ASSERT_CONDITION_TRUE2 (model, y, GE_EXPR, z);
-    ASSERT_CONDITION_UNKNOWN2 (model, x, GE_EXPR, z);
+    ASSERT_CONDITION_TRUE (model, y, GE_EXPR, z);
+    ASSERT_CONDITION_UNKNOWN (model, x, GE_EXPR, z);
 
     ADD_SAT_CONSTRAINT (model, y, EQ_EXPR, x);
 
     /* Assert various things about the insides of model.  */
-    constraint_manager2 *cm = model.get_constraints2 ();
+    constraint_manager *cm = model.get_constraints ();
     ASSERT_EQ (cm->m_constraints.length (), 1);
     ASSERT_EQ (cm->m_equiv_classes.length (), 2);
 
     /* Ensure that we merged the constraints.  */
-    ASSERT_CONDITION_TRUE2 (model, x, GE_EXPR, z);
+    ASSERT_CONDITION_TRUE (model, x, GE_EXPR, z);
   }
 
   /* x == 0, then x != 42.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
+    region_model_manager mgr;
+    region_model model (&mgr);
 
     ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, int_0);
     ADD_SAT_CONSTRAINT (model, x, NE_EXPR, int_42);
 
     /* Assert various things about the insides of model.  */
-    constraint_manager2 *cm = model.get_constraints2 ();
+    constraint_manager *cm = model.get_constraints ();
     ASSERT_EQ (cm->m_constraints.length (), 0);
     ASSERT_EQ (cm->m_equiv_classes.length (), 1);
 #if 0
     ASSERT_EQ (cm->m_constraints[0].m_lhs,
-	       cm->get_or_add_equiv_class2 (model.get_rvalue (int_0, NULL)));
+	       cm->get_or_add_equiv_class (model.get_rvalue (int_0, NULL)));
     ASSERT_EQ (cm->m_constraints[0].m_rhs,
-	       cm->get_or_add_equiv_class2 (model.get_rvalue (int_42, NULL)));
-    ASSERT_EQ (cm->m_constraints[0].m_op, CONSTRAINT2_LT);
+	       cm->get_or_add_equiv_class (model.get_rvalue (int_42, NULL)));
+    ASSERT_EQ (cm->m_constraints[0].m_op, CONSTRAINT_LT);
 #endif
   }
 
@@ -2810,12 +2749,12 @@ test_equality ()
   tree y = build_global_decl ("y", integer_type_node);
 
   {
-    region_model2_manager mgr;
-    region_model2 model0 (&mgr);
-    region_model2 model1 (&mgr);
+    region_model_manager mgr;
+    region_model model0 (&mgr);
+    region_model model1 (&mgr);
 
-    constraint_manager2 *cm0 = model0.get_constraints2 ();
-    constraint_manager2 *cm1 = model1.get_constraints2 ();
+    constraint_manager *cm0 = model0.get_constraints ();
+    constraint_manager *cm1 = model1.get_constraints ();
 
     ASSERT_EQ (cm0->hash (), cm1->hash ());
     ASSERT_EQ (*cm0, *cm1);
@@ -2834,17 +2773,17 @@ test_equality ()
 #endif
     ASSERT_NE (model0, model1);
 
-    region_model2 model2 (&mgr);
-    constraint_manager2 *cm2 = model2.get_constraints2 ();
-    /* Make the same change to cm2.  */
-    ADD_SAT_CONSTRAINT (model2, x, EQ_EXPR, y);
-    ASSERT_EQ (cm1->hash (), cm2->hash ());
-    ASSERT_EQ (*cm1, *cm2);
+    region_model model (&mgr);
+    constraint_manager *cm = model.get_constraints ();
+    /* Make the same change to cm.  */
+    ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, y);
+    ASSERT_EQ (cm1->hash (), cm->hash ());
+    ASSERT_EQ (*cm1, *cm);
 
 #if 0
-    ASSERT_EQ (model1.hash (), model2.hash ());
+    ASSERT_EQ (model1.hash (), model.hash ());
 #endif
-    ASSERT_EQ (model1, model2);
+    ASSERT_EQ (model1, model);
   }
 }
 
@@ -2855,8 +2794,8 @@ test_many_constants ()
 {
   tree a = build_global_decl ("a", integer_type_node);
 
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
   auto_vec<tree> constants;
   for (int i = 0; i < 20; i++)
     {
@@ -2865,10 +2804,10 @@ test_many_constants ()
       ADD_SAT_CONSTRAINT (model, a, NE_EXPR, constant);
 
       /* Merge, and check the result.  */
-      region_model2 other (model);
+      region_model other (model);
 
 #if 0
-      region_model2 merged (&mgr);
+      region_model merged (&mgr);
       ASSERT_TRUE (model.can_merge_with_p (other, &merged));
       model.canonicalize (NULL);
       merged.canonicalize (NULL);
@@ -2876,7 +2815,7 @@ test_many_constants ()
 #endif
 
       for (int j = 0; j <= i; j++)
-	ASSERT_CONDITION_TRUE2 (model, a, NE_EXPR, constants[j]);
+	ASSERT_CONDITION_TRUE (model, a, NE_EXPR, constants[j]);
     }
 }
 
@@ -2891,25 +2830,25 @@ test_redundant_constraints ()
 
   {
     /* i < 257 then i < 256.  */
-    region_model2_manager mgr;
-    region_model2 model0 (&mgr);
+    region_model_manager mgr;
+    region_model model0 (&mgr);
     ADD_SAT_CONSTRAINT (model0, i, LT_EXPR, int_257);
     ADD_SAT_CONSTRAINT (model0, i, LT_EXPR, int_256);
-    ASSERT_CONDITION_TRUE2 (model0, i, LT_EXPR, int_256);
-    ASSERT_CONDITION_TRUE2 (model0, i, LT_EXPR, int_257);
+    ASSERT_CONDITION_TRUE (model0, i, LT_EXPR, int_256);
+    ASSERT_CONDITION_TRUE (model0, i, LT_EXPR, int_257);
     /* The older constraint was made redundant by the newer;
        it should have been removed.  */
-    //ASSERT_EQ (model0.get_constraints2 ()->m_constraints.length (), 1);
-    //ASSERT_EQ (model1.get_constraints2 ()->m_equiv_classes.length (), 2);
+    //ASSERT_EQ (model0.get_constraints ()->m_constraints.length (), 1);
+    //ASSERT_EQ (model1.get_constraints ()->m_equiv_classes.length (), 2);
 
     /* i < 256 then i < 257.  */
-    region_model2 model1 (&mgr);
+    region_model model1 (&mgr);
     ADD_SAT_CONSTRAINT (model1, i, LT_EXPR, int_256);
     ADD_SAT_CONSTRAINT (model1, i, LT_EXPR, int_257);
-    ASSERT_CONDITION_TRUE2 (model1, i, LT_EXPR, int_256);
-    ASSERT_CONDITION_TRUE2 (model1, i, LT_EXPR, int_257);
-    ASSERT_EQ (model1.get_constraints2 ()->m_equiv_classes.length (), 2);
-    ASSERT_EQ (model1.get_constraints2 ()->m_constraints.length (), 1);
+    ASSERT_CONDITION_TRUE (model1, i, LT_EXPR, int_256);
+    ASSERT_CONDITION_TRUE (model1, i, LT_EXPR, int_257);
+    ASSERT_EQ (model1.get_constraints ()->m_equiv_classes.length (), 2);
+    ASSERT_EQ (model1.get_constraints ()->m_constraints.length (), 1);
 
     // TODO:
     //ASSERT_EQ (model1, model0);
@@ -2917,25 +2856,25 @@ test_redundant_constraints ()
 
   {
     /* i <= 257 then i <= 256.  */
-    region_model2_manager mgr;
-    region_model2 model0 (&mgr);
+    region_model_manager mgr;
+    region_model model0 (&mgr);
     ADD_SAT_CONSTRAINT (model0, i, LE_EXPR, int_257);
     ADD_SAT_CONSTRAINT (model0, i, LE_EXPR, int_256);
-    ASSERT_CONDITION_TRUE2 (model0, i, LE_EXPR, int_256);
-    ASSERT_CONDITION_TRUE2 (model0, i, LE_EXPR, int_257);
+    ASSERT_CONDITION_TRUE (model0, i, LE_EXPR, int_256);
+    ASSERT_CONDITION_TRUE (model0, i, LE_EXPR, int_257);
     /* The older constraint was made redundant by the newer;
        it should have been removed.  */
-    //ASSERT_EQ (model0.get_constraints2 ()->m_constraints.length (), 1);
-    //ASSERT_EQ (model1.get_constraints2 ()->m_equiv_classes.length (), 2);
+    //ASSERT_EQ (model0.get_constraints ()->m_constraints.length (), 1);
+    //ASSERT_EQ (model1.get_constraints ()->m_equiv_classes.length (), 2);
 
     /* i <= 256 then i <= 257.  */
-    region_model2 model1 (&mgr);
+    region_model model1 (&mgr);
     ADD_SAT_CONSTRAINT (model1, i, LE_EXPR, int_256);
     ADD_SAT_CONSTRAINT (model1, i, LE_EXPR, int_257);
-    ASSERT_CONDITION_TRUE2 (model1, i, LE_EXPR, int_256);
-    ASSERT_CONDITION_TRUE2 (model1, i, LE_EXPR, int_257);
-    ASSERT_EQ (model1.get_constraints2 ()->m_equiv_classes.length (), 2);
-    ASSERT_EQ (model1.get_constraints2 ()->m_constraints.length (), 1);
+    ASSERT_CONDITION_TRUE (model1, i, LE_EXPR, int_256);
+    ASSERT_CONDITION_TRUE (model1, i, LE_EXPR, int_257);
+    ASSERT_EQ (model1.get_constraints ()->m_equiv_classes.length (), 2);
+    ASSERT_EQ (model1.get_constraints ()->m_constraints.length (), 1);
 
     // TODO:
     //ASSERT_EQ (model1, model0);
diff --git a/gcc/analyzer/constraint-manager.h b/gcc/analyzer/constraint-manager.h
index 8fae2b488b1..8d8ccf8baab 100644
--- a/gcc/analyzer/constraint-manager.h
+++ b/gcc/analyzer/constraint-manager.h
@@ -18,19 +18,19 @@ 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_CONSTRAINT_MANAGER2_H
-#define GCC_ANALYZER_CONSTRAINT_MANAGER2_H
+#ifndef GCC_ANALYZER_CONSTRAINT_MANAGER_H
+#define GCC_ANALYZER_CONSTRAINT_MANAGER_H
 
 namespace ana {
 
-class constraint_manager2;
+class constraint_manager;
 
-/* One of the end-points of a range2.  */
+/* One of the end-points of a range.  */
 
-struct bound2
+struct bound
 {
-  bound2 () : m_constant (NULL_TREE), m_closed (false) {}
-  bound2 (tree constant, bool closed)
+  bound () : m_constant (NULL_TREE), m_closed (false) {}
+  bound (tree constant, bool closed)
   : m_constant (constant), m_closed (closed) {}
 
   void ensure_closed (bool is_upper);
@@ -44,10 +44,10 @@ struct bound2
 /* A range of values, used for determining if a value has been
    constrained to just one possible constant value.  */
 
-struct range2
+struct range
 {
-  range2 () : m_lower_bound (), m_upper_bound () {}
-  range2 (const bound2 &lower, const bound2 &upper)
+  range () : m_lower_bound (), m_upper_bound () {}
+  range (const bound &lower, const bound &upper)
   : m_lower_bound (lower), m_upper_bound (upper) {}
 
   void dump_to_pp (pretty_printer *pp) const;
@@ -60,29 +60,29 @@ struct range2
   bool below_lower_bound (tree rhs_const) const;
   bool above_upper_bound (tree rhs_const) const;
 
-  bound2 m_lower_bound;
-  bound2 m_upper_bound;
+  bound m_lower_bound;
+  bound m_upper_bound;
 };
 
 /* An equivalence class within a constraint manager: a set of
-   svalue_ids that are known to all be equal to each other,
+   svalues that are known to all be equal to each other,
    together with an optional tree constant that they are equal to.  */
 
-class equiv_class2
+class equiv_class
 {
 public:
-  equiv_class2 ();
-  equiv_class2 (const equiv_class2 &other);
+  equiv_class ();
+  equiv_class (const equiv_class &other);
 
   hashval_t hash () const;
-  bool operator== (const equiv_class2 &other);
+  bool operator== (const equiv_class &other);
 
-  void add (const svalue2 *sval);
-  bool del (const svalue2 *sval);
+  void add (const svalue *sval);
+  bool del (const svalue *sval);
 
   tree get_any_constant () const { return m_constant; }
 
-  const svalue2 *get_representative () const;
+  const svalue *get_representative () const;
 
   void canonicalize ();
 
@@ -92,52 +92,52 @@ public:
      different zeroes, for different types); these are just for the last
      constant added.  */
   tree m_constant;
-  const svalue2 *m_cst_sval;
+  const svalue *m_cst_sval;
 
   // TODO: should this be a set rather than a vec?
-  auto_vec<const svalue2 *> m_vars;
+  auto_vec<const svalue *> m_vars;
 };
 
 /* The various kinds of constraint.  */
 
-enum constraint2_op
+enum constraint_op
 {
-  CONSTRAINT2_NE,
-  CONSTRAINT2_LT,
-  CONSTRAINT2_LE
+  CONSTRAINT_NE,
+  CONSTRAINT_LT,
+  CONSTRAINT_LE
 };
 
-const char *constraint_op_code (enum constraint2_op c_op);
+const char *constraint_op_code (enum constraint_op c_op);
 
-/* An ID for an equiv_class2 within a constraint_manager2.  Internally, this
-   is an index into a vector of equiv_class2 * within the constraint_manager2.  */
+/* An ID for an equiv_class within a constraint_manager.  Internally, this
+   is an index into a vector of equiv_class * within the constraint_manager.  */
 
-class equiv_class2_id
+class equiv_class_id
 {
 public:
-  static equiv_class2_id null () { return equiv_class2_id (-1); }
+  static equiv_class_id null () { return equiv_class_id (-1); }
 
-  equiv_class2_id (unsigned idx) : m_idx (idx) {}
-  const equiv_class2 &get_obj (const constraint_manager2 &cm) const;
-  equiv_class2 &get_obj (constraint_manager2 &cm) const;
+  equiv_class_id (unsigned idx) : m_idx (idx) {}
+  const equiv_class &get_obj (const constraint_manager &cm) const;
+  equiv_class &get_obj (constraint_manager &cm) const;
 
-  bool operator== (const equiv_class2_id &other) const
+  bool operator== (const equiv_class_id &other) const
   {
     return m_idx == other.m_idx;
   }
-  bool operator!= (const equiv_class2_id &other) const
+  bool operator!= (const equiv_class_id &other) const
   {
     return m_idx != other.m_idx;
   }
 
   bool null_p () const { return m_idx == -1; }
 
-  static equiv_class2_id from_int (int idx) { return equiv_class2_id (idx); }
+  static equiv_class_id from_int (int idx) { return equiv_class_id (idx); }
   int as_int () const { return m_idx; }
 
   void print (pretty_printer *pp) const;
 
-  void update_for_removal (equiv_class2_id other)
+  void update_for_removal (equiv_class_id other)
   {
     if (m_idx > other.m_idx)
       m_idx--;
@@ -146,69 +146,69 @@ public:
   int m_idx;
 };
 
-/* A relationship between two equivalence classes in a constraint_manager2.  */
+/* A relationship between two equivalence classes in a constraint_manager.  */
 
-class constraint2
+class constraint
 {
  public:
-  constraint2 (equiv_class2_id lhs, enum constraint2_op c_op, equiv_class2_id rhs)
+  constraint (equiv_class_id lhs, enum constraint_op c_op, equiv_class_id rhs)
   : m_lhs (lhs), m_op (c_op), m_rhs (rhs)
   {
     gcc_assert (!lhs.null_p ());
     gcc_assert (!rhs.null_p ());
   }
 
-  void print (pretty_printer *pp, const constraint_manager2 &cm) const;
+  void print (pretty_printer *pp, const constraint_manager &cm) const;
 
   hashval_t hash () const;
-  bool operator== (const constraint2 &other) const;
+  bool operator== (const constraint &other) const;
 
   /* Is this an ordering, rather than a "!=".  */
   bool is_ordering_p () const
   {
-    return m_op != CONSTRAINT2_NE;
+    return m_op != CONSTRAINT_NE;
   }
 
-  bool implied_by (const constraint2 &other,
-		   const constraint_manager2 &cm) const;
+  bool implied_by (const constraint &other,
+		   const constraint_manager &cm) const;
 
-  equiv_class2_id m_lhs;
-  enum constraint2_op m_op;
-  equiv_class2_id m_rhs;
+  equiv_class_id m_lhs;
+  enum constraint_op m_op;
+  equiv_class_id m_rhs;
 };
 
-/* An abstract base class for use with constraint_manager2::for_each_fact.  */
+/* An abstract base class for use with constraint_manager::for_each_fact.  */
 
-class fact2_visitor
+class fact_visitor
 {
  public:
-  virtual ~fact2_visitor () {}
-  virtual void on_fact (const svalue2 *lhs,
+  virtual ~fact_visitor () {}
+  virtual void on_fact (const svalue *lhs,
 			enum tree_code,
-			const svalue2 *rhs) = 0;
+			const svalue *rhs) = 0;
 };
 
 /* A collection of equivalence classes and constraints on them.
 
-   Given N svalue2s, this can be thought of as representing a subset of
+   Given N svalues, this can be thought of as representing a subset of
    N-dimensional space.  When we call add_constraint,
    we are effectively taking an intersection with that constraint.  */
 
-class constraint_manager2
+class constraint_manager
 {
 public:
-  constraint_manager2 (region_model2_manager *mgr) : m_mgr (mgr) {}
-  constraint_manager2 (const constraint_manager2 &other);
-  virtual ~constraint_manager2 () {}
+  constraint_manager (region_model_manager *mgr) : m_mgr (mgr) {}
+  constraint_manager (const constraint_manager &other);
+  virtual ~constraint_manager () {}
 
 #if 0
-  virtual constraint_manager2 *clone (region_model2 *) const = 0;
+  virtual constraint_manager *clone (region_model *) const = 0;
 #endif
-  constraint_manager2& operator= (const constraint_manager2 &other);
+  constraint_manager& operator= (const constraint_manager &other);
 
   hashval_t hash () const;
-  bool operator== (const constraint_manager2 &other) const;
-  bool operator!= (const constraint_manager2 &other) const
+  bool operator== (const constraint_manager &other) const;
+  bool operator!= (const constraint_manager &other) const
   {
     return !(*this == other);
   }
@@ -218,80 +218,80 @@ public:
   void dump (FILE *fp) const;
   void dump () const;
 
-  const equiv_class2 &get_equiv_class2_by_index (unsigned idx) const
+  const equiv_class &get_equiv_class_by_index (unsigned idx) const
   {
     return *m_equiv_classes[idx];
   }
-  equiv_class2 &get_equiv_class2_by_index (unsigned idx)
+  equiv_class &get_equiv_class_by_index (unsigned idx)
   {
     return *m_equiv_classes[idx];
   }
 
-  equiv_class2 &get_equiv_class2 (const svalue2 *sval)
+  equiv_class &get_equiv_class (const svalue *sval)
   {
-    equiv_class2_id ec_id = get_or_add_equiv_class2 (sval);
+    equiv_class_id ec_id = get_or_add_equiv_class (sval);
     return ec_id.get_obj (*this);
   }
 
-  bool add_constraint (const svalue2 *lhs,
+  bool add_constraint (const svalue *lhs,
 		       enum tree_code op,
-		       const svalue2 *rhs);
+		       const svalue *rhs);
 
-  bool add_constraint (equiv_class2_id lhs_ec_id,
+  bool add_constraint (equiv_class_id lhs_ec_id,
 		       enum tree_code op,
-		       equiv_class2_id rhs_ec_id);
+		       equiv_class_id rhs_ec_id);
 
-  void add_unknown_constraint (equiv_class2_id lhs_ec_id,
+  void add_unknown_constraint (equiv_class_id lhs_ec_id,
 			       enum tree_code op,
-			       equiv_class2_id rhs_ec_id);
+			       equiv_class_id rhs_ec_id);
 
-  bool get_equiv_class2_by_svalue2 (const svalue2 *sval,
-				    equiv_class2_id *out) const;
-  equiv_class2_id get_or_add_equiv_class2 (const svalue2 *sval);
-  tristate eval_condition (equiv_class2_id lhs,
+  bool get_equiv_class_by_svalue (const svalue *sval,
+				    equiv_class_id *out) const;
+  equiv_class_id get_or_add_equiv_class (const svalue *sval);
+  tristate eval_condition (equiv_class_id lhs,
 			   enum tree_code op,
-			   equiv_class2_id rhs) const;
-  tristate eval_condition (equiv_class2_id lhs_ec,
+			   equiv_class_id rhs) const;
+  tristate eval_condition (equiv_class_id lhs_ec,
 			   enum tree_code op,
 			   tree rhs_const) const;
-  tristate eval_condition (const svalue2 *lhs,
+  tristate eval_condition (const svalue *lhs,
 			   enum tree_code op,
-			   const svalue2 *rhs) const;
-  range2 get_ec_bounds (equiv_class2_id ec_id) const;
+			   const svalue *rhs) const;
+  range get_ec_bounds (equiv_class_id ec_id) const;
 
   /* PurgeCriteria should have:
-     bool should_purge_p (const svalue2 *sval) const.  */
+     bool should_purge_p (const svalue *sval) const.  */
   template <typename PurgeCriteria>
-  void purge (const PurgeCriteria &p, purge_stats2 *stats);
+  void purge (const PurgeCriteria &p, purge_stats *stats);
 
-  void on_liveness_change (const hash_set<const svalue2 *> &live_svalues,
-			   const region_model2 *model);
+  void on_liveness_change (const hash_set<const svalue *> &live_svalues,
+			   const region_model *model);
 
   void canonicalize ();
 
-  static void merge (const constraint_manager2 &cm_a,
-		     const constraint_manager2 &cm_b,
-		     constraint_manager2 *out,
-		     const model2_merger &merger);
+  static void merge (const constraint_manager &cm_a,
+		     const constraint_manager &cm_b,
+		     constraint_manager *out,
+		     const model_merger &merger);
 
-  void for_each_fact (fact2_visitor *) const;
+  void for_each_fact (fact_visitor *) const;
 
   void validate () const;
 
-  auto_delete_vec<equiv_class2> m_equiv_classes;
-  auto_vec<constraint2> m_constraints;
+  auto_delete_vec<equiv_class> m_equiv_classes;
+  auto_vec<constraint> m_constraints;
 
  private:
-  static void clean_merger_input (const constraint_manager2 &cm_in,
-				  constraint_manager2 *out);
+  static void clean_merger_input (const constraint_manager &cm_in,
+				  constraint_manager *out);
 
-  void add_constraint_internal (equiv_class2_id lhs_id,
-				enum constraint2_op c_op,
-				equiv_class2_id rhs_id);
+  void add_constraint_internal (equiv_class_id lhs_id,
+				enum constraint_op c_op,
+				equiv_class_id rhs_id);
 
-  region_model2_manager *m_mgr;
+  region_model_manager *m_mgr;
 };
 
 } // namespace ana
 
-#endif /* GCC_ANALYZER_CONSTRAINT_MANAGER2_H */
+#endif /* GCC_ANALYZER_CONSTRAINT_MANAGER_H */
diff --git a/gcc/analyzer/diagnostic-manager.cc b/gcc/analyzer/diagnostic-manager.cc
index 6824c27ab7e..d16a4445712 100644
--- a/gcc/analyzer/diagnostic-manager.cc
+++ b/gcc/analyzer/diagnostic-manager.cc
@@ -72,7 +72,7 @@ saved_diagnostic::saved_diagnostic (const state_machine *sm,
 				    const supernode *snode, const gimple *stmt,
 				    stmt_finder *stmt_finder,
 				    tree var,
-				    const svalue2 *sval,
+				    const svalue *sval,
 				    state_machine::state_t state,
 				    pending_diagnostic *d)
 : m_sm (sm), m_enode (enode), m_snode (snode), m_stmt (stmt),
@@ -153,7 +153,7 @@ private:
 
 /* diagnostic_manager's ctor.  */
 
-diagnostic_manager::diagnostic_manager (logger *logger, engine2 *eng,
+diagnostic_manager::diagnostic_manager (logger *logger, engine *eng,
 					int verbosity)
 : log_user (logger), m_eng (eng), m_verbosity (verbosity)
 {
@@ -167,7 +167,7 @@ diagnostic_manager::add_diagnostic (const state_machine *sm,
 				    const supernode *snode, const gimple *stmt,
 				    stmt_finder *finder,
 				    tree var,
-				    const svalue2 *sval,
+				    const svalue *sval,
 				    state_machine::state_t state,
 				    pending_diagnostic *d)
 {
@@ -336,7 +336,7 @@ public:
 class dedupe_winners
 {
 public:
-  dedupe_winners (engine2 *eng) : m_engine2 (eng) {}
+  dedupe_winners (engine *eng) : m_engine (eng) {}
 
   ~dedupe_winners ()
   {
@@ -379,7 +379,7 @@ public:
 
     feasibility_problem *p = NULL;
     bool feasible;
-    feasible = dc->get_path ().feasible2_p (logger, &p, m_engine2, eg);
+    feasible = dc->get_path ().feasible_p (logger, &p, m_engine, eg);
     if (!feasible)
       {
 	if (logger)
@@ -475,7 +475,7 @@ public:
   }
 
 private:
-  engine2 *m_engine2;
+  engine *m_engine;
 
   /* This maps from each dedupe_key to a current best dedupe_candidate.  */
 
@@ -512,7 +512,7 @@ diagnostic_manager::emit_saved_diagnostics (const exploded_graph &eg)
      instance.  This partitions the saved diagnostics by dedupe_key,
      generating exploded_paths for them, and retaining the best one in each
      partition.  */
-  dedupe_winners best_candidates (eg.get_engine2 ());
+  dedupe_winners best_candidates (eg.get_engine ());
 
   int i;
   saved_diagnostic *sd;
@@ -644,10 +644,10 @@ get_any_origin (const gimple *stmt,
 
 /* FIXME.  */
 
-static const svalue2 *
-get_any_origin2 (const gimple *stmt,
-		 const svalue2 *dst_sval,
-		 const program_state &dst_state)
+static const svalue *
+get_any_origin (const gimple *stmt,
+		const svalue *dst_sval,
+		const program_state &dst_state)
 {
   gcc_unreachable ();
 }
@@ -671,10 +671,10 @@ diagnostic_manager::build_emission_path (const path_builder &pb,
 /* Subclass of state_change_visitor that creates state_change_event
    instances.  */
 
-class state_change_event_creator2 : public state_change_visitor2
+class state_change_event_creator : public state_change_visitor
 {
 public:
-  state_change_event_creator2 (const exploded_edge &eedge,
+  state_change_event_creator (const exploded_edge &eedge,
 			      checker_path *emission_path)
     : m_eedge (eedge),
       m_emission_path (emission_path)
@@ -710,8 +710,8 @@ public:
   bool on_state_change (const state_machine &sm,
 			state_machine::state_t src_sm_val,
 			state_machine::state_t dst_sm_val,
-			const svalue2 *sval,
-			const svalue2 *dst_origin_sval) FINAL OVERRIDE
+			const svalue *sval,
+			const svalue *dst_origin_sval) FINAL OVERRIDE
   {
     const exploded_node *src_node = m_eedge.m_src;
     const program_point &src_point = src_node->get_point ();
@@ -737,7 +737,7 @@ public:
       return false;
 
     tree origin_rep
-      = dst_state.get_representative_tree2 (dst_origin_sval);
+      = dst_state.get_representative_tree (dst_origin_sval);
 #if 0
     if (origin_rep == NULL_TREE)
       origin_rep = get_any_origin (stmt, dst_rep, dst_state);
@@ -776,20 +776,20 @@ public:
    lead to state_change_events being emitted).  */
 
 bool
-for_each_state_change2 (const program_state &src_state,
-			const program_state &dst_state,
-			const extrinsic_state &ext_state,
-			state_change_visitor2 *visitor)
+for_each_state_change (const program_state &src_state,
+		       const program_state &dst_state,
+		       const extrinsic_state &ext_state,
+		       state_change_visitor *visitor)
 {
-  gcc_assert (src_state.m_checker_states2.length ()
+  gcc_assert (src_state.m_checker_states.length ()
 	      == ext_state.get_num_checkers ());
-  gcc_assert (dst_state.m_checker_states2.length ()
+  gcc_assert (dst_state.m_checker_states.length ()
 	      == ext_state.get_num_checkers ());
   for (unsigned i = 0; i < ext_state.get_num_checkers (); i++)
     {
       const state_machine &sm = ext_state.get_sm (i);
-      const sm_state_map2 &src_smap = *src_state.m_checker_states2[i];
-      const sm_state_map2 &dst_smap = *dst_state.m_checker_states2[i];
+      const sm_state_map &src_smap = *src_state.m_checker_states[i];
+      const sm_state_map &dst_smap = *dst_state.m_checker_states[i];
 
       /* Add events for any global state changes.  */
       if (src_smap.get_global_state () != dst_smap.get_global_state ())
@@ -799,20 +799,20 @@ for_each_state_change2 (const program_state &src_state,
 	  return true;
 
       /* Add events for per-svalue state changes.  */
-      for (sm_state_map2::iterator_t iter = dst_smap.begin ();
+      for (sm_state_map::iterator_t iter = dst_smap.begin ();
 	   iter != dst_smap.end ();
 	   ++iter)
 	{
 #if 1
 	  // FIXME: we can compare them now
 	  // FIXME: do we want to sort them first, then emit events?
-	  const svalue2 *sval = (*iter).first;
-	  tree dst_rep = dst_state.get_representative_tree2 (sval);
+	  const svalue *sval = (*iter).first;
+	  tree dst_rep = dst_state.get_representative_tree (sval);
 	  state_machine::state_t dst_sm_val = (*iter).second.m_state;
 	  state_machine::state_t src_sm_val = src_smap.get_state (sval, ext_state);
 	  if (dst_sm_val != src_sm_val)
 	    {
-	      const svalue2 *origin_sval = (*iter).second.m_origin;
+	      const svalue *origin_sval = (*iter).second.m_origin;
 	      if (visitor->on_state_change (sm, src_sm_val, dst_sm_val,
 					    sval, origin_sval))
 		return true;
@@ -822,8 +822,8 @@ for_each_state_change2 (const program_state &src_state,
 	     and dst state, but there's no guarantee that the IDs can
 	     be meaningfully compared.  */
 	  auto_vec<path_var> dst_pvs;
-	  dst_state.m_region_model2->get_path_vars_for_svalue (dst_sval,
-							       &dst_pvs);
+	  dst_state.m_region_model->get_path_vars_for_svalue (dst_sval,
+							      &dst_pvs);
 
 	  unsigned j;
 	  path_var *dst_pv;
@@ -835,14 +835,14 @@ for_each_state_change2 (const program_state &src_state,
 		  >= src_state.m_region_model->get_stack_depth ())
 		continue;
 	      tentative_region_model_context ctxt;
-	      const svalue2 *src_sval
-		= src_state.m_region_model2->get_rvalue (*dst_pv, &ctxt);
+	      const svalue *src_sval
+		= src_state.m_region_model->get_rvalue (*dst_pv, &ctxt);
 	      if (src_val == NULL || ctxt.had_errors_p ())
 		continue;
 	      state_machine::state_t src_sm_val = src_smap.get_state (src_sval);
 	      if (dst_sm_val != src_sm_val)
 		{
-		  const svalue2 *dst_origin_sval = (*iter).second.m_origin;
+		  const svalue *dst_origin_sval = (*iter).second.m_origin;
 		  if (visitor->on_state_change (sm, src_sm_val, dst_sm_val,
 						dst_rep, dst_origin_sval))
 		    return true;
@@ -854,7 +854,7 @@ for_each_state_change2 (const program_state &src_state,
   return false;
 }
 
-/* An sm_context for adding state_change2_event on assignments to NULL,
+/* An sm_context for adding state_change_event on assignments to NULL,
    where the default state isn't m_start.  Storing such state in the
    sm_state_map would lead to bloat of the exploded_graph, so we want
    to leave it as a default state, and inject state change events here
@@ -889,8 +889,8 @@ struct null_assignment_sm_context : public sm_context
     if (from != 0)
       return;
 
-    const svalue2 *var_new_sval
-      = m_new_state->m_region_model2->get_rvalue (var, NULL);
+    const svalue *var_new_sval
+      = m_new_state->m_region_model->get_rvalue (var, NULL);
     const supernode *supernode = m_point->get_supernode ();
     int stack_depth = m_point->get_stack_depth ();
 
@@ -936,8 +936,8 @@ struct null_assignment_sm_context : public sm_context
     const gassign *assign_stmt = dyn_cast <const gassign *> (stmt);
     if (!assign_stmt)
      return NULL_TREE;
-    if (const svalue2 *sval
-	= m_new_state->m_region_model2->get_gassign_result (assign_stmt, NULL))
+    if (const svalue *sval
+	= m_new_state->m_region_model->get_gassign_result (assign_stmt, NULL))
       if (tree cst = sval->maybe_get_constant ())
 	if (::zerop(cst))
 	  return gimple_assign_lhs (assign_stmt);
@@ -946,7 +946,7 @@ struct null_assignment_sm_context : public sm_context
 
   const program_state *m_new_state;
   const program_point *m_point;
-  state_change_visitor2 *m_visitor;
+  state_change_visitor *m_visitor;
   const gimple *m_stmt;
   checker_path *m_emission_path;
 };
@@ -994,9 +994,9 @@ diagnostic_manager::add_events_for_eedge (const path_builder &pb,
       | ~~~~~~~~~~~~~^~~~~
       |              |
       |              (3) ...to here        (end_cfg_edge_event).  */
-  state_change_event_creator2 visitor2 (eedge, emission_path);
-  for_each_state_change2 (src_state, dst_state, pb.get_ext_state (),
-			  &visitor2);
+  state_change_event_creator visitor (eedge, emission_path);
+  for_each_state_change (src_state, dst_state, pb.get_ext_state (),
+			 &visitor);
 
   /* Allow non-standard edges to add events, e.g. when rewinding from
      longjmp to a setjmp.  */
@@ -1044,7 +1044,7 @@ diagnostic_manager::add_events_for_eedge (const path_builder &pb,
 	/* Create state change events for assignment to NULL.
 	   Iterate through the stmts in dst_enode, adding state change
 	   events for them.  */
-	if (dst_state.m_region_model2)
+	if (dst_state.m_region_model)
 	  {
 	    program_state iter_state (dst_state);
 	    program_point iter_point (dst_point);
@@ -1054,7 +1054,7 @@ diagnostic_manager::add_events_for_eedge (const path_builder &pb,
 		if (stmt->code == GIMPLE_ASSIGN)
 		  {
 		    const extrinsic_state &ext_state = pb.get_ext_state ();
-		    iter_state.m_region_model2->on_stmt (stmt, NULL);
+		    iter_state.m_region_model->on_stmt (stmt, NULL);
 		    for (unsigned i = 0; i < ext_state.get_num_checkers (); i++)
 		      {
 			const state_machine &sm = ext_state.get_sm (i);
@@ -1254,12 +1254,12 @@ void
 diagnostic_manager::prune_path (checker_path *path,
 				const state_machine *sm,
 				tree var,
-				const svalue2 *sval,
+				const svalue *sval,
 				state_machine::state_t state) const
 {
   LOG_FUNC (get_logger ());
   path->maybe_log (get_logger (), "path");
-  prune_for_sm_diagnostic2 (path, sm, sval, state);
+  prune_for_sm_diagnostic (path, sm, sval, state);
   prune_interproc_events (path);
   finish_pruning (path);
   path->maybe_log (get_logger (), "pruned");
@@ -1301,10 +1301,10 @@ can_be_expr_of_interest_p (tree expr)
    when the diagnostic relates to later dereferencing 'ptr'.  */
 
 void
-diagnostic_manager::prune_for_sm_diagnostic2 (checker_path *path,
-					      const state_machine *sm,
-					      const svalue2 *sval,
-					      state_machine::state_t state)
+diagnostic_manager::prune_for_sm_diagnostic (checker_path *path,
+					     const state_machine *sm,
+					     const svalue *sval,
+					     state_machine::state_t state)
   const
 {
   int idx = path->num_events () - 1;
@@ -1356,8 +1356,8 @@ diagnostic_manager::prune_for_sm_diagnostic2 (checker_path *path,
 		statement_event *stmt_event = (statement_event *)base_event;
 		// TODO:
 #if 0
-		const svalue2 *new_sval
-		  = get_any_origin2 (stmt_event->m_stmt, sval,
+		const svalue *new_sval
+		  = get_any_origin (stmt_event->m_stmt, sval,
 				     stmt_event->m_dst_state);
 		if (new_sval)
 		  {
@@ -1394,7 +1394,7 @@ diagnostic_manager::prune_for_sm_diagnostic2 (checker_path *path,
 	    state_change_event *state_change
 	      = (state_change_event *)base_event;
 	    bool ctxt_had_errors = false;
-	    gcc_assert (state_change->m_dst_state.m_region_model2);
+	    gcc_assert (state_change->m_dst_state.m_region_model);
 
 	    if (state_change->m_sval == sval)
 	      {
@@ -1509,8 +1509,8 @@ diagnostic_manager::prune_for_sm_diagnostic2 (checker_path *path,
 	    call_event *event = (call_event *)base_event;
 	    const callgraph_superedge& cg_superedge
 	      = event->get_callgraph_superedge ();
-	    const region_model2 *callee_model
-	      = event->m_eedge.m_dest->get_state ().m_region_model2;
+	    const region_model *callee_model
+	      = event->m_eedge.m_dest->get_state ().m_region_model;
 	    tree callee_var = callee_model->get_representative_tree (sval);
 #if 1
 	    /* We could just use caller_model->get_representative_tree (sval);
@@ -1521,8 +1521,8 @@ diagnostic_manager::prune_for_sm_diagnostic2 (checker_path *path,
 	    tree caller_var
 	      = cg_superedge.map_expr_from_callee_to_caller (callee_var, &expr);
 #else
-	    const region_model2 *caller_model
-	      = m_eedge.m_src->get_state ()->m_region_model2;
+	    const region_model *caller_model
+	      = m_eedge.m_src->get_state ()->m_region_model;
 	    tree caller_var = caller_model->get_representative_tree (sval);
 #endif
 	    if (caller_var)
@@ -1548,8 +1548,8 @@ diagnostic_manager::prune_for_sm_diagnostic2 (checker_path *path,
 		return_event *event = (return_event *)base_event;
 		const callgraph_superedge& cg_superedge
 		  = event->get_callgraph_superedge ();
-		const region_model2 *caller_model
-		  = event->m_eedge.m_dest->get_state ().m_region_model2;
+		const region_model *caller_model
+		  = event->m_eedge.m_dest->get_state ().m_region_model;
 		tree caller_var = caller_model->get_representative_tree (sval);
 		callsite_expr expr;
 		tree callee_var
diff --git a/gcc/analyzer/diagnostic-manager.h b/gcc/analyzer/diagnostic-manager.h
index d72bac55794..d531413ede1 100644
--- a/gcc/analyzer/diagnostic-manager.h
+++ b/gcc/analyzer/diagnostic-manager.h
@@ -39,7 +39,7 @@ public:
 		    const exploded_node *enode,
 		    const supernode *snode, const gimple *stmt,
 		    stmt_finder *stmt_finder,
-		    tree var, const svalue2 *sval,
+		    tree var, const svalue *sval,
 		    state_machine::state_t state,
 		    pending_diagnostic *d);
   ~saved_diagnostic ();
@@ -74,7 +74,7 @@ public:
   const gimple *m_stmt;
   stmt_finder *m_stmt_finder;
   tree m_var;
-  const svalue2 *m_sval;
+  const svalue *m_sval;
   state_machine::state_t m_state;
   pending_diagnostic *m_d;
   exploded_edge *m_trailing_eedge;
@@ -101,16 +101,16 @@ class path_builder;
 class diagnostic_manager : public log_user
 {
 public:
-  diagnostic_manager (logger *logger, engine2 *eng, int verbosity);
+  diagnostic_manager (logger *logger, engine *eng, int verbosity);
 
-  engine2 *get_engine2 () const { return m_eng; }
+  engine *get_engine () const { return m_eng; }
 
   void add_diagnostic (const state_machine *sm,
 		       const exploded_node *enode,
 		       const supernode *snode, const gimple *stmt,
 		       stmt_finder *finder,
 		       tree var,
-		       const svalue2 *sval,
+		       const svalue *sval,
 		       state_machine::state_t state,
 		       pending_diagnostic *d);
 
@@ -159,22 +159,22 @@ private:
   void prune_path (checker_path *path,
 		   const state_machine *sm,
 		   tree var,
-		   const svalue2 *sval,
+		   const svalue *sval,
 		   state_machine::state_t state) const;
 
   void prune_for_sm_diagnostic (checker_path *path,
 				const state_machine *sm,
 				tree var,
 				state_machine::state_t state) const;
-  void prune_for_sm_diagnostic2 (checker_path *path,
+  void prune_for_sm_diagnostic (checker_path *path,
 				 const state_machine *sm,
-				 const svalue2 *sval,
+				 const svalue *sval,
 				 state_machine::state_t state) const;
   void update_for_unsuitable_sm_exprs (tree *expr) const;
   void prune_interproc_events (checker_path *path) const;
   void finish_pruning (checker_path *path) const;
 
-  engine2 *m_eng;
+  engine *m_eng;
   auto_delete_vec<saved_diagnostic> m_saved_diagnostics;
   const int m_verbosity;
 };
diff --git a/gcc/analyzer/engine.cc b/gcc/analyzer/engine.cc
index 65c8172eeb9..411e34cb509 100644
--- a/gcc/analyzer/engine.cc
+++ b/gcc/analyzer/engine.cc
@@ -67,10 +67,10 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace ana {
 
-/* class impl_region_model2_context : public region_model_context.  */
+/* class impl_region_model_context : public region_model_context.  */
 
-impl_region_model2_context::
-impl_region_model2_context (exploded_graph &eg,
+impl_region_model_context::
+impl_region_model_context (exploded_graph &eg,
 			   const exploded_node *enode_for_diag,
 			   const program_state *old_state,
 			   program_state *new_state,
@@ -86,10 +86,10 @@ impl_region_model2_context (exploded_graph &eg,
 {
 }
 
-impl_region_model2_context::
-impl_region_model2_context (program_state *state,
-			    const extrinsic_state &ext_state,
-			    logger *logger)
+impl_region_model_context::
+impl_region_model_context (program_state *state,
+			   const extrinsic_state &ext_state,
+			   logger *logger)
 : m_eg (NULL), m_logger (logger), m_enode_for_diag (NULL),
   m_old_state (NULL),
   m_new_state (state),
@@ -100,7 +100,7 @@ impl_region_model2_context (program_state *state,
 }
 
 void
-impl_region_model2_context::warn (pending_diagnostic *d)
+impl_region_model_context::warn (pending_diagnostic *d)
 {
   LOG_FUNC (get_logger ());
   if (m_eg)
@@ -110,13 +110,13 @@ impl_region_model2_context::warn (pending_diagnostic *d)
 }
 
 void
-impl_region_model2_context::on_svalue2_leak (const svalue2 *sval)
+impl_region_model_context::on_svalue_leak (const svalue *sval)
 
 {
   int sm_idx;
-  sm_state_map2 *smap;
-  FOR_EACH_VEC_ELT (m_new_state->m_checker_states2, sm_idx, smap)
-    smap->on_svalue2_leak (sval, this);
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
+    smap->on_svalue_leak (sval, this);
 
 #if 0
   // FIXME: what is/was this used for?
@@ -126,66 +126,66 @@ impl_region_model2_context::on_svalue2_leak (const svalue2 *sval)
 }
 
 void
-impl_region_model2_context::
-on_liveness_change (const hash_set<const svalue2 *> &live_svalues,
-		    const region_model2 *model)
+impl_region_model_context::
+on_liveness_change (const hash_set<const svalue *> &live_svalues,
+		    const region_model *model)
 {
   int sm_idx;
-  sm_state_map2 *smap;
-  FOR_EACH_VEC_ELT (m_new_state->m_checker_states2, sm_idx, smap)
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     smap->on_liveness_change (live_svalues, model, this);
 }
 
 void
-impl_region_model2_context::on_unknown_change (const svalue2 *sval,
-					       bool is_mutable)
+impl_region_model_context::on_unknown_change (const svalue *sval,
+					      bool is_mutable)
 {
   int sm_idx;
-  sm_state_map2 *smap;
-  FOR_EACH_VEC_ELT (m_new_state->m_checker_states2, sm_idx, smap)
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     {
       const state_machine &sm = m_ext_state.get_sm (sm_idx);
       smap->on_unknown_change (sm, sval, is_mutable, m_ext_state);
     }
 }
 
-/* class setjmp_svalue2 : public svalue2.  */
+/* class setjmp_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-setjmp_svalue2::accept (visitor *v) const
+setjmp_svalue::accept (visitor *v) const
 {
-  v->visit_setjmp_svalue2 (this);
+  v->visit_setjmp_svalue (this);
 }
 
 /* FIXME.  */
 
 void
-setjmp_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+setjmp_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     pp_printf (pp, "SETJMP(EN: %i)", get_enode_index ());
   else
-    pp_printf (pp, "setjmp_svalue2(EN%i)", get_enode_index ());
+    pp_printf (pp, "setjmp_svalue(EN%i)", get_enode_index ());
 }
 
-/* Compare the fields of this setjmp_svalue2 with OTHER, returning true
+/* Compare the fields of this setjmp_svalue with OTHER, returning true
    if they are equal.
-   For use by svalue2::operator==.  */
+   For use by svalue::operator==.  */
 
 #if 0
 bool
-setjmp_svalue2::compare_fields (const setjmp_svalue2 &other) const
+setjmp_svalue::compare_fields (const setjmp_svalue &other) const
 {
   return m_setjmp_record == other.m_setjmp_record;
 }
 #endif
 
-/* Implementation of svalue2::add_to_hash vfunc for setjmp_svalue2.  */
+/* Implementation of svalue::add_to_hash vfunc for setjmp_svalue.  */
 #if 0
 void
-setjmp_svalue2::add_to_hash (inchash::hash &hstate) const
+setjmp_svalue::add_to_hash (inchash::hash &hstate) const
 {
   hstate.add_int (m_setjmp_record.m_enode->m_index);
 }
@@ -194,7 +194,7 @@ setjmp_svalue2::add_to_hash (inchash::hash &hstate) const
 /* Get the index of the stored exploded_node.  */
 
 int
-setjmp_svalue2::get_enode_index () const
+setjmp_svalue::get_enode_index () const
 {
   return m_setjmp_record.m_enode->m_index;
 }
@@ -203,17 +203,17 @@ setjmp_svalue2::get_enode_index () const
 /* Concrete implementation of sm_context, wiring it up to the rest of this
    file.  */
 
-class impl_sm_context2 : public sm_context
+class impl_sm_context : public sm_context
 {
 public:
-  impl_sm_context2 (exploded_graph &eg,
+  impl_sm_context (exploded_graph &eg,
 		    int sm_idx,
 		    const state_machine &sm,
 		    const exploded_node *enode_for_diag,
 		    const program_state *old_state,
 		    program_state *new_state,
-		    const sm_state_map2 *old_smap,
-		    sm_state_map2 *new_smap,
+		    const sm_state_map *old_smap,
+		    sm_state_map *new_smap,
 		    stmt_finder *stmt_finder = NULL)
   : sm_context (sm_idx, sm),
     m_logger (eg.get_logger ()),
@@ -228,10 +228,10 @@ public:
 
   tree get_fndecl_for_call (const gcall *call) FINAL OVERRIDE
   {
-    impl_region_model2_context old_ctxt
+    impl_region_model_context old_ctxt
       (m_eg, m_enode_for_diag, NULL, NULL/*m_enode->get_state ()*/,
        call);
-    region_model2 *model = m_new_state->m_region_model2;
+    region_model *model = m_new_state->m_region_model;
     return model->get_fndecl_for_call (call, &old_ctxt);
   }
 
@@ -244,19 +244,19 @@ public:
   {
     logger * const logger = get_logger ();
     LOG_FUNC (logger);
-    impl_region_model2_context old_ctxt
+    impl_region_model_context old_ctxt
       (m_eg, m_enode_for_diag, NULL, NULL/*m_enode->get_state ()*/,
        stmt);
-    const svalue2 *var_old_sval
-      = m_old_state->m_region_model2->get_rvalue (var, &old_ctxt);
+    const svalue *var_old_sval
+      = m_old_state->m_region_model->get_rvalue (var, &old_ctxt);
 
-    impl_region_model2_context new_ctxt (m_eg, m_enode_for_diag,
+    impl_region_model_context new_ctxt (m_eg, m_enode_for_diag,
 					 m_old_state, m_new_state,
 					 stmt);
-    const svalue2 *var_new_sval
-      = m_new_state->m_region_model2->get_rvalue (var, &new_ctxt);
-    const svalue2 *origin_new_sval
-      = m_new_state->m_region_model2->get_rvalue (origin, &new_ctxt);
+    const svalue *var_new_sval
+      = m_new_state->m_region_model->get_rvalue (var, &new_ctxt);
+    const svalue *origin_new_sval
+      = m_new_state->m_region_model->get_rvalue (origin, &new_ctxt);
 
     state_machine::state_t current
       = m_old_smap->get_state (var_old_sval, m_eg.get_ext_state ());
@@ -268,7 +268,7 @@ public:
 		       var,
 		       m_sm.get_state_name (from),
 		       m_sm.get_state_name (to));
-	m_new_smap->set_state (m_new_state->m_region_model2, var_new_sval,
+	m_new_smap->set_state (m_new_state->m_region_model, var_new_sval,
 			       to, origin_new_sval, m_eg.get_ext_state ());
 #if 0
 	if (m_change)
@@ -284,13 +284,13 @@ public:
     LOG_FUNC (get_logger ());
     gcc_assert (d); // take ownership
 
-    impl_region_model2_context old_ctxt
+    impl_region_model_context old_ctxt
       (m_eg, m_enode_for_diag, m_old_state, m_new_state, NULL);
     state_machine::state_t current;
     if (var)
       {
-	const svalue2 *var_old_sval
-	  = m_old_state->m_region_model2->get_rvalue (var, &old_ctxt);
+	const svalue *var_old_sval
+	  = m_old_state->m_region_model->get_rvalue (var, &old_ctxt);
 	current = m_old_smap->get_state (var_old_sval, m_eg.get_ext_state ());
       }
     else
@@ -298,8 +298,8 @@ public:
 
     if (state == current)
       {
-	const svalue2 *var_old_sval
-	  = m_old_state->m_region_model2->get_rvalue (var, &old_ctxt);
+	const svalue *var_old_sval
+	  = m_old_state->m_region_model->get_rvalue (var, &old_ctxt);
 	m_eg.get_diagnostic_manager ().add_diagnostic
 	  (&m_sm, m_enode_for_diag, snode, stmt, m_stmt_finder,
 	   var, var_old_sval, state, d);
@@ -324,9 +324,9 @@ public:
       return expr;
 
     gcc_assert (m_new_state);
-    const svalue2 *sval = m_new_state->m_region_model2->get_rvalue (expr, NULL);
+    const svalue *sval = m_new_state->m_region_model->get_rvalue (expr, NULL);
     /* Find trees for all regions storing the value.  */
-    if (tree t = m_new_state->m_region_model2->get_representative_tree (sval))
+    if (tree t = m_new_state->m_region_model->get_representative_tree (sval))
       return t;
     else
       return expr;
@@ -334,12 +334,12 @@ public:
 
   state_machine::state_t get_global_state () const FINAL OVERRIDE
   {
-    return m_old_state->m_checker_states2[m_sm_idx]->get_global_state ();
+    return m_old_state->m_checker_states[m_sm_idx]->get_global_state ();
   }
 
   void set_global_state (state_machine::state_t state) FINAL OVERRIDE
   {
-    m_new_state->m_checker_states2[m_sm_idx]->set_global_state (state);
+    m_new_state->m_checker_states[m_sm_idx]->set_global_state (state);
   }
 
   void on_custom_transition (custom_transition *transition) FINAL OVERRIDE
@@ -354,10 +354,10 @@ public:
     const gassign *assign_stmt = dyn_cast <const gassign *> (stmt);
     if (!assign_stmt)
      return NULL_TREE;
-    impl_region_model2_context old_ctxt
+    impl_region_model_context old_ctxt
       (m_eg, m_enode_for_diag, m_old_state, m_new_state, stmt);
-    if (const svalue2 *sval
-	= m_new_state->m_region_model2->get_gassign_result (assign_stmt,
+    if (const svalue *sval
+	= m_new_state->m_region_model->get_gassign_result (assign_stmt,
 							    &old_ctxt))
       if (tree cst = sval->maybe_get_constant ())
 	if (::zerop(cst))
@@ -370,8 +370,8 @@ public:
   const exploded_node *m_enode_for_diag;
   const program_state *m_old_state;
   program_state *m_new_state;
-  const sm_state_map2 *m_old_smap;
-  sm_state_map2 *m_new_smap;
+  const sm_state_map *m_old_smap;
+  sm_state_map *m_new_smap;
   stmt_finder *m_stmt_finder;
 };
 
@@ -542,9 +542,9 @@ readability_comparator (const void *p1, const void *p2)
    it can potentially complain about a leak of SVAL in the given STATE.  */
 
 void
-impl_region_model2_context::on_state_leak (const state_machine &sm,
+impl_region_model_context::on_state_leak (const state_machine &sm,
 					   int sm_idx,
-					   const svalue2 *sval,
+					   const svalue *sval,
 					   state_machine::state_t state)
 {
   logger * const logger = get_logger ();
@@ -579,9 +579,9 @@ impl_region_model2_context::on_state_leak (const state_machine &sm,
      leak per EC, this ought to ensure that we pick the most
      user-readable description of each leaking EC.
      This assumes that all vars in the EC have the same state.  */
-  hash_set <const svalue2 *> visited;
+  hash_set <const svalue *> visited;
   path_var leaked_pv
-    = m_old_state->m_region_model2->get_representative_path_var (sval,
+    = m_old_state->m_region_model->get_representative_path_var (sval,
 								 &visited);
 
   /* This might be NULL; the pending_diagnostic subclasses need to cope
@@ -625,17 +625,17 @@ impl_region_model2_context::on_state_leak (const state_machine &sm,
    state transitions.  */
 
 void
-impl_region_model2_context::on_condition (tree lhs, enum tree_code op, tree rhs)
+impl_region_model_context::on_condition (tree lhs, enum tree_code op, tree rhs)
 {
   int sm_idx;
-  sm_state_map2 *smap;
-  FOR_EACH_VEC_ELT (m_new_state->m_checker_states2, sm_idx, smap)
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     {
       const state_machine &sm = m_ext_state.get_sm (sm_idx);
-      impl_sm_context2 sm_ctxt (*m_eg, sm_idx, sm, m_enode_for_diag,
+      impl_sm_context sm_ctxt (*m_eg, sm_idx, sm, m_enode_for_diag,
 				m_old_state, m_new_state,
-				m_old_state->m_checker_states2[sm_idx],
-				m_new_state->m_checker_states2[sm_idx]);
+				m_old_state->m_checker_states[sm_idx],
+				m_new_state->m_checker_states[sm_idx]);
       sm.on_condition (&sm_ctxt,
 		       m_enode_for_diag->get_supernode (), m_stmt,
 		       lhs, op, rhs);
@@ -647,17 +647,17 @@ impl_region_model2_context::on_condition (tree lhs, enum tree_code op, tree rhs)
    state transitions.  */
 
 void
-impl_region_model2_context::on_phi (const gphi *phi, tree rhs)
+impl_region_model_context::on_phi (const gphi *phi, tree rhs)
 {
   int sm_idx;
-  sm_state_map2 *smap;
-  FOR_EACH_VEC_ELT (m_new_state->m_checker_states2, sm_idx, smap)
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     {
       const state_machine &sm = m_ext_state.get_sm (sm_idx);
-      impl_sm_context2 sm_ctxt (*m_eg, sm_idx, sm, m_enode_for_diag,
+      impl_sm_context sm_ctxt (*m_eg, sm_idx, sm, m_enode_for_diag,
 				m_old_state, m_new_state,
-				m_old_state->m_checker_states2[sm_idx],
-				m_new_state->m_checker_states2[sm_idx]);
+				m_old_state->m_checker_states[sm_idx],
+				m_new_state->m_checker_states[sm_idx]);
       sm.on_phi (&sm_ctxt, m_enode_for_diag->get_supernode (), phi, rhs);
     }
 }
@@ -667,7 +667,7 @@ impl_region_model2_context::on_phi (const gphi *phi, tree rhs)
    TODO(stage1): introduce a warning for when this occurs.  */
 
 void
-impl_region_model2_context::on_unexpected_tree_code (tree t,
+impl_region_model_context::on_unexpected_tree_code (tree t,
 						    const dump_location_t &loc)
 {
   logger * const logger = get_logger ();
@@ -701,14 +701,14 @@ point_and_state::validate (const extrinsic_state &ext_state) const
      of the region_model.  */
   /* They should have the same depth.  */
   gcc_assert (m_point.get_stack_depth ()
-	      == m_state.m_region_model2->get_stack_depth ());
+	      == m_state.m_region_model->get_stack_depth ());
   /* Check the functions in the callstring vs those in the frames
      at each depth.  */
   for (int depth = 0; depth < m_point.get_stack_depth (); ++depth)
     {
 #if 0
       gcc_assert (m_point.get_function_at_depth (depth)
-		  == m_state.m_region_model2->get_function_at_depth (depth));
+		  == m_state.m_region_model->get_function_at_depth (depth));
 #endif
     }
 }
@@ -804,8 +804,7 @@ exploded_node::exploded_node (const point_and_state &ps,
 : m_ps (ps), m_status (STATUS_WORKLIST), m_index (index),
   m_num_processed_stmts (0)
 {
-  if (ps.get_state ().m_region_model2)
-    gcc_checking_assert (ps.get_state ().m_region_model2->canonicalized_p ());
+  gcc_checking_assert (ps.get_state ().m_region_model->canonicalized_p ());
 }
 
 /* Get the stmt that was processed in this enode at index IDX.  */
@@ -841,10 +840,10 @@ exploded_node::get_dot_fillcolor () const
   int total_sm_state = 0;
   {
     int i;
-    sm_state_map2 *smap;
-    FOR_EACH_VEC_ELT (state.m_checker_states2, i, smap)
+    sm_state_map *smap;
+    FOR_EACH_VEC_ELT (state.m_checker_states, i, smap)
       {
-	for (sm_state_map2::iterator_t iter = smap->begin ();
+	for (sm_state_map::iterator_t iter = smap->begin ();
 	     iter != smap->end ();
 	     ++iter)
 	  total_sm_state += (*iter).second.m_state;
@@ -1058,10 +1057,10 @@ exploded_node::on_stmt (exploded_graph &eg,
      source construct we're failing to handle.  */
   input_location = stmt->location;
 
-  gcc_assert (state->m_region_model2);
+  gcc_assert (state->m_region_model);
 #if 0
     {
-      if (state->m_region_model2->on_stmt (snode, stmt))
+      if (state->m_region_model->on_stmt (snode, stmt))
 	return on_stmt_flags (false);
       else
 	return on_stmt_flags::terminate_path ();
@@ -1074,15 +1073,15 @@ exploded_node::on_stmt (exploded_graph &eg,
      going from tree to svalue_id.  */
   const program_state old_state (*state);
 
-  impl_region_model2_context ctxt (eg, this,
+  impl_region_model_context ctxt (eg, this,
 				   &old_state, state,
 				   stmt);
 
   if (const gassign *assign = dyn_cast <const gassign *> (stmt))
-    state->m_region_model2->on_stmt (stmt, &ctxt);
+    state->m_region_model->on_stmt (stmt, &ctxt);
 
   if (const greturn *return_ = dyn_cast <const greturn *> (stmt))
-    state->m_region_model2->on_stmt (stmt/*, return_*/, &ctxt);
+    state->m_region_model->on_stmt (stmt/*, return_*/, &ctxt);
 
   /* Track whether we have a gcall to a function that's not recognized by
      anything, for which we don't have a function body, or for which we
@@ -1092,7 +1091,7 @@ exploded_node::on_stmt (exploded_graph &eg,
     {
       /* Debugging/test support.  */
       if (is_special_named_call_p (call, "__analyzer_describe", 2))
-	state->m_region_model2->impl_call_analyzer_describe (call, &ctxt);
+	state->m_region_model->impl_call_analyzer_describe (call, &ctxt);
       else if (is_special_named_call_p (call, "__analyzer_dump", 0))
 	{
 	  /* Handle the builtin "__analyzer_dump" by dumping state
@@ -1109,10 +1108,10 @@ exploded_node::on_stmt (exploded_graph &eg,
 	{
 	  /* Handle the builtin "__analyzer_dump_region_model" by dumping
 	     the region model's state to stderr.  */
-	  state->m_region_model2->dump (false);
+	  state->m_region_model->dump (false);
 	}
       else if (is_special_named_call_p (call, "__analyzer_eval", 1))
-	state->m_region_model2->impl_call_analyzer_eval (call, &ctxt);
+	state->m_region_model->impl_call_analyzer_eval (call, &ctxt);
       else if (is_special_named_call_p (call, "__analyzer_break", 0))
 	{
 	  /* Handle the builtin "__analyzer_break" by triggering a
@@ -1126,26 +1125,26 @@ exploded_node::on_stmt (exploded_graph &eg,
 	  /* This is handled elsewhere.  */
 	}
       else if (is_setjmp_call_p (call))
-	state->m_region_model2->on_setjmp (call, this, &ctxt);
+	state->m_region_model->on_setjmp (call, this, &ctxt);
       else if (is_longjmp_call_p (call))
 	{
-	  on_longjmp2 (eg, call, state, &ctxt);
+	  on_longjmp (eg, call, state, &ctxt);
 	  return on_stmt_flags::terminate_path ();
 	}
       else
-	unknown_side_effects = state->m_region_model2->on_call_pre (call, &ctxt);
+	unknown_side_effects = state->m_region_model->on_call_pre (call, &ctxt);
     }
 
   bool any_sm_changes = false;
   int sm_idx;
-  sm_state_map2 *smap;
-  FOR_EACH_VEC_ELT (old_state.m_checker_states2, sm_idx, smap)
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (old_state.m_checker_states, sm_idx, smap)
     {
       const state_machine &sm = eg.get_ext_state ().get_sm (sm_idx);
-      const sm_state_map2 *old_smap
-	= old_state.m_checker_states2[sm_idx];
-      sm_state_map2 *new_smap = state->m_checker_states2[sm_idx];
-      impl_sm_context2 sm_ctxt (eg, sm_idx, sm, this, &old_state, state,
+      const sm_state_map *old_smap
+	= old_state.m_checker_states[sm_idx];
+      sm_state_map *new_smap = state->m_checker_states[sm_idx];
+      impl_sm_context sm_ctxt (eg, sm_idx, sm, this, &old_state, state,
 				old_smap, new_smap);
       /* Allow the state_machine to handle the stmt.  */
       if (sm.on_stmt (&sm_ctxt, snode, stmt))
@@ -1156,11 +1155,11 @@ exploded_node::on_stmt (exploded_graph &eg,
 	  if (const gcall *call = dyn_cast <const gcall *> (stmt))
 	    {
 	      tree callee_fndecl
-		= state->m_region_model2->get_fndecl_for_call (call, &ctxt);
+		= state->m_region_model->get_fndecl_for_call (call, &ctxt);
 
 	      if (!fndecl_has_gimple_body_p (callee_fndecl))
 		new_smap->purge_for_unknown_fncall (eg, call, callee_fndecl,
-						    state->m_region_model2,
+						    state->m_region_model,
 						    &ctxt);
 	    }
 	}
@@ -1169,7 +1168,7 @@ exploded_node::on_stmt (exploded_graph &eg,
     }
 
   if (const gcall *call = dyn_cast <const gcall *> (stmt))
-    state->m_region_model2->on_call_post (call, unknown_side_effects, &ctxt);
+    state->m_region_model->on_call_post (call, unknown_side_effects, &ctxt);
 
   return on_stmt_flags (any_sm_changes);
 }
@@ -1274,25 +1273,25 @@ private:
    handling the various kinds of failure that can occur.  */
 
 void
-exploded_node::on_longjmp2 (exploded_graph &eg,
+exploded_node::on_longjmp (exploded_graph &eg,
 			    const gcall *longjmp_call,
 			    program_state *new_state,
-			    region_model2_context *ctxt) const
+			    region_model_context *ctxt) const
 {
   tree buf_ptr = gimple_call_arg (longjmp_call, 0);
 
-  region_model2 *new_region_model = new_state->m_region_model2;
-  const svalue2 *buf_ptr_sval = new_region_model->get_rvalue (buf_ptr, ctxt);
-  const region2 *buf = new_region_model->deref_rvalue (buf_ptr_sval, buf_ptr,
+  region_model *new_region_model = new_state->m_region_model;
+  const svalue *buf_ptr_sval = new_region_model->get_rvalue (buf_ptr, ctxt);
+  const region *buf = new_region_model->deref_rvalue (buf_ptr_sval, buf_ptr,
 						       ctxt);
   if (!buf)
     return; // FIXME: can it be NULL?
 
-  const svalue2 *buf_content_sval = new_region_model->get_store_value (buf);
+  const svalue *buf_content_sval = new_region_model->get_store_value (buf);
   if (!buf_content_sval) // FIXME: can it be NULL?
     return;
-  const setjmp_svalue2 *setjmp_sval
-    = buf_content_sval->dyn_cast_setjmp_svalue2 ();
+  const setjmp_svalue *setjmp_sval
+    = buf_content_sval->dyn_cast_setjmp_svalue ();
   if (!setjmp_sval)
     return;
 
@@ -1329,7 +1328,7 @@ exploded_node::on_longjmp2 (exploded_graph &eg,
 				setjmp_point.get_stack_depth (), ctxt);
 
   /* Detect leaks in the new state relative to the old state.  */
-  program_state::detect_leaks2 (get_state (), *new_state, NULL,
+  program_state::detect_leaks (get_state (), *new_state, NULL,
 				eg.get_ext_state (), ctxt);
 
   program_point next_point
@@ -1411,16 +1410,16 @@ exploded_node::detect_leaks (exploded_graph &eg) const
      what leaks (via purge_unused_svalues).  */
   program_state new_state (old_state);
 
-  gcc_assert (new_state.m_region_model2);
+  gcc_assert (new_state.m_region_model);
 
-  purge_stats2 stats;
-  impl_region_model2_context ctxt (eg, this,
+  purge_stats stats;
+  impl_region_model_context ctxt (eg, this,
 				   &old_state, &new_state,
 				   get_stmt ());
-  const svalue2 *result = NULL;
-  new_state.m_region_model2->pop_frame (NULL, true, &stats, &result,
+  const svalue *result = NULL;
+  new_state.m_region_model->pop_frame (NULL, true, &stats, &result,
 					&ctxt);
-  program_state::detect_leaks2 (old_state, new_state, result,
+  program_state::detect_leaks (old_state, new_state, result,
 				eg.get_ext_state (), &ctxt);
 }
 
@@ -1461,7 +1460,7 @@ exploded_node::dump_succs_and_preds (FILE *outf) const
    state).  */
 
 void
-rewind_info_t::update_model2 (region_model2 *model,
+rewind_info_t::update_model (region_model *model,
 			      const exploded_edge &eedge)
 {
   const program_point &longjmp_point = eedge.m_src->get_point ();
@@ -1842,11 +1841,11 @@ worklist::key_t::cmp (const worklist::key_t &ka, const worklist::key_t &kb)
   /* Sort by sm-state, so that identical sm-states are grouped
      together in the worklist.
      For now, sort by the hash value (might not be deterministic).  */
-  for (unsigned sm_idx = 0; sm_idx < state_a.m_checker_states2.length ();
+  for (unsigned sm_idx = 0; sm_idx < state_a.m_checker_states.length ();
        ++sm_idx)
     {
-      sm_state_map2 *smap_a = state_a.m_checker_states2[sm_idx];
-      sm_state_map2 *smap_b = state_b.m_checker_states2[sm_idx];
+      sm_state_map *smap_a = state_a.m_checker_states[sm_idx];
+      sm_state_map *smap_b = state_b.m_checker_states[sm_idx];
 
       hashval_t hash_a = smap_a->hash ();
       hashval_t hash_b = smap_b->hash ();
@@ -1876,7 +1875,7 @@ exploded_graph::exploded_graph (const supergraph &sg, logger *logger,
   m_ext_state (ext_state),
   m_purge_map (purge_map),
   m_plan (plan),
-  m_diagnostic_manager (logger, ext_state.get_engine2 (), verbosity),
+  m_diagnostic_manager (logger, ext_state.get_engine (), verbosity),
   m_global_stats (m_sg.num_nodes ()),
   m_functionless_stats (m_sg.num_nodes ()),
   m_PK_AFTER_SUPERNODE_per_snode (m_sg.num_nodes ())
@@ -1993,7 +1992,7 @@ exploded_graph::get_or_create_node (const program_point &point,
       pp_string (pp, "pruned_state: ");
       pruned_state.dump_to_pp (m_ext_state, true, false, pp);
       logger->end_log_line ();
-      pruned_state.m_region_model2->dump_to_pp (logger->get_printer (), true,
+      pruned_state.m_region_model->dump_to_pp (logger->get_printer (), true,
 						false);
     }
 
@@ -2158,10 +2157,10 @@ exploded_graph::add_edge (exploded_node *src, exploded_node *dest,
 
 #if 0
   // TODO: detect leaks
-  if (dest->get_state ().m_region_model2)
+  if (dest->get_state ().m_region_model)
     {
       // FIXME:
-      program_state::detect_leaks2 (src->get_state (),
+      program_state::detect_leaks (src->get_state (),
 				    dest->get_state (),
 				    m_ext_state);
     }
@@ -2569,15 +2568,15 @@ exploded_graph::process_node (exploded_node *node)
 
 	if (point.get_from_edge ())
 	  {
-	    impl_region_model2_context ctxt2 (*this, node,
+	    impl_region_model_context ctxt (*this, node,
 					      &state, &next_state, NULL);
 	    const cfg_superedge *last_cfg_superedge
 	      = point.get_from_edge ()->dyn_cast_cfg_superedge ();
 	    if (last_cfg_superedge)
-	      next_state.m_region_model2->update_for_phis
+	      next_state.m_region_model->update_for_phis
 		(node->get_supernode (),
 		 last_cfg_superedge,
-		 &ctxt2);
+		 &ctxt);
 	  }
 
 	if (point.get_supernode ()->m_stmts.length () > 0)
@@ -2653,11 +2652,11 @@ exploded_graph::process_node (exploded_node *node)
 	    if (flags.m_terminate_path)
 	      return;
 
-	    if (next_state.m_region_model2)
+	    if (next_state.m_region_model)
 	      {
-		impl_region_model2_context ctxt (*this, node,
+		impl_region_model_context ctxt (*this, node,
 						 &old_state, &next_state, stmt);
-		program_state::detect_leaks2 (old_state, next_state, NULL,
+		program_state::detect_leaks (old_state, next_state, NULL,
 					      get_ext_state (), &ctxt);
 	      }
 
@@ -2897,7 +2896,7 @@ exploded_graph::log_stats () const
 
   LOG_SCOPE (logger);
 
-  m_ext_state.get_engine2 ()->log_stats (logger);
+  m_ext_state.get_engine ()->log_stats (logger);
 
   logger->log ("m_sg.num_nodes (): %i", m_sg.num_nodes ());
   logger->log ("m_nodes.length (): %i", m_nodes.length ());
@@ -3010,15 +3009,15 @@ exploded_path::get_final_enode () const
    feasibility_problem to *OUT.  */
 
 bool
-exploded_path::feasible2_p (logger *logger, feasibility_problem **out,
-			    engine2 *eng, const exploded_graph *eg) const
+exploded_path::feasible_p (logger *logger, feasibility_problem **out,
+			    engine *eng, const exploded_graph *eg) const
 {
   LOG_SCOPE (logger);
 
   auto_sbitmap snodes_visited (eg->get_supergraph ().m_nodes.length ());
 
   /* Traverse the path, updating this model.  */
-  region_model2 model (eng->get_model_manager ());
+  region_model model (eng->get_model_manager ());
   for (unsigned edge_idx = 0; edge_idx < m_edges.length (); edge_idx++)
     {
       const exploded_edge *eedge = m_edges[edge_idx];
@@ -3094,7 +3093,7 @@ exploded_path::feasible2_p (logger *logger, feasibility_problem **out,
 	    }
 	  else if (eedge->m_custom_info)
 	    {
-	      eedge->m_custom_info->update_model2 (&model, *eedge);
+	      eedge->m_custom_info->update_model (&model, *eedge);
 	    }
 	}
 
@@ -3116,13 +3115,13 @@ exploded_path::feasible2_p (logger *logger, feasibility_problem **out,
 				     NULL);
 	      /* If we've entering an snode that we've already visited on this
 		 epath, then we need do fix things up for loops; see the
-		 comment for store2::loop_replay_hack.
+		 comment for store::loop_replay_hack.
 		 Perhaps we should probably also verify the callstring,
 		 and track program_points,  but hopefully doing it by supernode
 		 is good enough.  */
 	      if (bitmap_bit_p (snodes_visited, dst_snode_idx))
 		model.loop_replay_hack
-		  (dst_enode.get_state ().m_region_model2);
+		  (dst_enode.get_state ().m_region_model);
 	    }
 	  bitmap_set_bit (snodes_visited, dst_snode_idx);
 	}
@@ -4167,7 +4166,7 @@ impl_run_checkers (logger *logger)
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
     node->get_untransformed_body ();
 
-  engine2 eng;
+  engine eng;
 
   /* Create the supergraph.  */
   supergraph sg (logger);
diff --git a/gcc/analyzer/exploded-graph.h b/gcc/analyzer/exploded-graph.h
index 1655a4ad878..3dc4f051994 100644
--- a/gcc/analyzer/exploded-graph.h
+++ b/gcc/analyzer/exploded-graph.h
@@ -28,10 +28,10 @@ namespace ana {
 /* Concrete implementation of region_model_context, wiring it up to the
    rest of the analysis engine.  */
 
-class impl_region_model2_context : public region_model2_context
+class impl_region_model_context : public region_model_context
 {
  public:
-  impl_region_model2_context (exploded_graph &eg,
+  impl_region_model_context (exploded_graph &eg,
 			     const exploded_node *enode_for_diag,
 
 			     /* TODO: should we be getting the ECs from the
@@ -42,31 +42,24 @@ class impl_region_model2_context : public region_model2_context
 			     const gimple *stmt,
 			     stmt_finder *stmt_finder = NULL);
 
-  impl_region_model2_context (program_state *state,
-			      const extrinsic_state &ext_state,
-			      logger *logger = NULL);
+  impl_region_model_context (program_state *state,
+			     const extrinsic_state &ext_state,
+			     logger *logger = NULL);
 
   void warn (pending_diagnostic *d) FINAL OVERRIDE;
-  void on_svalue2_leak (const svalue2 *) OVERRIDE;
-  void on_liveness_change (const hash_set<const svalue2 *> &live_svalues,
-			   const region_model2 *model) FINAL OVERRIDE;
+  void on_svalue_leak (const svalue *) OVERRIDE;
+  void on_liveness_change (const hash_set<const svalue *> &live_svalues,
+			   const region_model *model) FINAL OVERRIDE;
   logger *get_logger () FINAL OVERRIDE
   {
     return m_logger.get_logger ();
   }
   void on_state_leak (const state_machine &sm,
 		      int sm_idx,
-		      const svalue2 *sval,
+		      const svalue *sval,
 		      state_machine::state_t state);
-#if 0
-  void on_inherited_svalue (svalue_id parent_sid,
-			    svalue_id child_sid) FINAL OVERRIDE;
-
-  void on_cast (svalue_id src_sid,
-		svalue_id dst_sid) FINAL OVERRIDE;
-#endif
   void on_condition (tree lhs, enum tree_code op, tree rhs) FINAL OVERRIDE;
-  void on_unknown_change (const svalue2 *sval, bool is_mutable) FINAL OVERRIDE;
+  void on_unknown_change (const svalue *sval, bool is_mutable) FINAL OVERRIDE;
   void on_phi (const gphi *phi, tree rhs) FINAL OVERRIDE;
   void on_unexpected_tree_code (tree t,
 				const dump_location_t &loc) FINAL OVERRIDE;
@@ -233,10 +226,10 @@ class exploded_node : public dnode<eg_traits>
 		const superedge *succ,
 		program_point *next_point,
 		program_state *next_state) const;
-  void on_longjmp2 (exploded_graph &eg,
+  void on_longjmp (exploded_graph &eg,
 		    const gcall *call,
 		    program_state *new_state,
-		    region_model2_context *ctxt) const;
+		    region_model_context *ctxt) const;
 
   void detect_leaks (exploded_graph &eg) const;
 
@@ -307,7 +300,7 @@ class exploded_edge : public dedge<eg_traits>
     virtual void print (pretty_printer *pp) = 0;
 
     /* Hook for updating MODEL within exploded_path::feasible_p.  */
-    virtual void update_model2 (region_model2 *model,
+    virtual void update_model (region_model *model,
 				const exploded_edge &eedge) = 0;
 
     virtual void add_events_to_path (checker_path *emission_path,
@@ -356,7 +349,7 @@ public:
     pp_string (pp, "rewind");
   }
 
-  void update_model2 (region_model2 *model,
+  void update_model (region_model *model,
 		      const exploded_edge &eedge) FINAL OVERRIDE;
 
   void add_events_to_path (checker_path *emission_path,
@@ -741,7 +734,7 @@ public:
 
   const supergraph &get_supergraph () const { return m_sg; }
   const extrinsic_state &get_ext_state () const { return m_ext_state; }
-  engine2 *get_engine2 () const { return m_ext_state.get_engine2 (); }
+  engine *get_engine () const { return m_ext_state.get_engine (); }
   const state_purge_map *get_purge_map () const { return m_purge_map; }
   const analysis_plan &get_analysis_plan () const { return m_plan; }
 
@@ -872,8 +865,8 @@ public:
   void dump () const;
 
   bool feasible_p (logger *logger, feasibility_problem **out) const;
-  bool feasible2_p (logger *logger, feasibility_problem **out,
-		    engine2 *eng, const exploded_graph *eg) const;
+  bool feasible_p (logger *logger, feasibility_problem **out,
+		    engine *eng, const exploded_graph *eg) const;
 
   auto_vec<const exploded_edge *> m_edges;
 };
@@ -884,7 +877,7 @@ class feasibility_problem
 {
 public:
   feasibility_problem (unsigned eedge_idx,
-		       const region_model2 &model,
+		       const region_model &model,
 		       const exploded_edge &eedge,
 		       const gimple *last_stmt)
   : m_eedge_idx (eedge_idx), m_model (model), m_eedge (eedge),
@@ -898,12 +891,12 @@ public:
     m_last_stmt (last_stmt)
   {
     /* FIXME: eventually remove this in favor of porting fully to
-       region_model2.  */
+       region_model.  */
   }
 #endif
 
   unsigned m_eedge_idx;
-  region_model2 m_model;
+  region_model m_model;
   const exploded_edge &m_eedge;
   const gimple *m_last_stmt;
 };
diff --git a/gcc/analyzer/program-state.cc b/gcc/analyzer/program-state.cc
index f80f10dca84..6d1761ca005 100644
--- a/gcc/analyzer/program-state.cc
+++ b/gcc/analyzer/program-state.cc
@@ -100,11 +100,11 @@ extrinsic_state::dump () const
 
 /* FIXME.  */
 
-region_model2_manager *
+region_model_manager *
 extrinsic_state::get_model_manager () const
 {
-  if (m_engine2)
-    return m_engine2->get_model_manager ();
+  if (m_engine)
+    return m_engine->get_model_manager ();
   else
     return NULL; /* for selftests.  */
 }
@@ -171,30 +171,30 @@ extrinsic_state::get_model_manager () const
 
 /* Assert that this object is sane.  */
 
-/* class sm_state_map2.  */
+/* class sm_state_map.  */
 
-/* sm_state_map2's ctor.  */
+/* sm_state_map's ctor.  */
 
-sm_state_map2::sm_state_map2 (const state_machine &sm,
+sm_state_map::sm_state_map (const state_machine &sm,
 			      int sm_idx)
   : m_sm (sm), m_sm_idx (sm_idx), m_map (), m_global_state (0)
 {
 }
 
-/* Clone the sm_state_map2.  */
+/* Clone the sm_state_map.  */
 
-sm_state_map2 *
-sm_state_map2::clone () const
+sm_state_map *
+sm_state_map::clone () const
 {
-  return new sm_state_map2 (*this);
+  return new sm_state_map (*this);
 }
 
-/* Print this sm_state_map2 to PP.
+/* Print this sm_state_map to PP.
    If MODEL is non-NULL, print representative tree values where
    available.  */
 
 void
-sm_state_map2::print (const region_model2 *model,
+sm_state_map::print (const region_model *model,
 		      bool simple, bool multiline,
 		      pretty_printer *pp) const
 {
@@ -219,7 +219,7 @@ sm_state_map2::print (const region_model2 *model,
       else if (!first)
 	pp_string (pp, ", ");
       first = false;
-      const svalue2 *sval = (*iter).first;
+      const svalue *sval = (*iter).first;
       pp_pointer (pp, sval);
       pp_string (pp, ": ");
       sval->dump_to_pp (pp, simple);
@@ -262,7 +262,7 @@ sm_state_map2::print (const region_model2 *model,
 /* Dump this object (for SM) to stderr.  */
 
 DEBUG_FUNCTION void
-sm_state_map2::dump (bool simple) const
+sm_state_map::dump (bool simple) const
 {
   pretty_printer pp;
   pp_show_color (&pp) = pp_show_color (global_dc->printer);
@@ -276,15 +276,15 @@ sm_state_map2::dump (bool simple) const
    (all expressions are for the start state).  */
 
 bool
-sm_state_map2::is_empty_p () const
+sm_state_map::is_empty_p () const
 {
   return m_map.elements () == 0 && m_global_state == 0;
 }
 
-/* Generate a hash value for this sm_state_map2.  */
+/* Generate a hash value for this sm_state_map.  */
 
 hashval_t
-sm_state_map2::hash () const
+sm_state_map::hash () const
 {
   hashval_t result = 0;
 
@@ -307,10 +307,10 @@ sm_state_map2::hash () const
   return result;
 }
 
-/* Equality operator for sm_state_map2.  */
+/* Equality operator for sm_state_map.  */
 
 bool
-sm_state_map2::operator== (const sm_state_map2 &other) const
+sm_state_map::operator== (const sm_state_map &other) const
 {
   if (m_global_state != other.m_global_state)
     return false;
@@ -322,7 +322,7 @@ sm_state_map2::operator== (const sm_state_map2 &other) const
        iter != m_map.end ();
        ++iter)
     {
-      const svalue2 *sval = (*iter).first;
+      const svalue *sval = (*iter).first;
       entry_t e = (*iter).second;
       entry_t *other_slot = const_cast <map_t &> (other.m_map).get (sval);
       if (other_slot == NULL)
@@ -340,13 +340,13 @@ sm_state_map2::operator== (const sm_state_map2 &other) const
    States default to the start state.  */
 
 state_machine::state_t
-sm_state_map2::get_state (const svalue2 *sval,
+sm_state_map::get_state (const svalue *sval,
 			  const extrinsic_state &ext_state) const
 {
   gcc_assert (sval);
 
 #if NULL_POINTER_TYPE_CONSOLIDATION
-  sval = canonicalize_svalue2 (sval, ext_state);
+  sval = canonicalize_svalue (sval, ext_state);
 #endif
 
   if (entry_t *slot
@@ -359,15 +359,15 @@ sm_state_map2::get_state (const svalue2 *sval,
      For example INIT_VAL(foo.field) might inherit taintedness state from
      INIT_VAL(foo).  */
   if (m_sm.inherited_state_p ())
-    if (region_model2_manager *mgr = ext_state.get_model_manager ())
-      if (const initial_svalue2 *init_sval = sval->dyn_cast_initial_svalue2 ())
+    if (region_model_manager *mgr = ext_state.get_model_manager ())
+      if (const initial_svalue *init_sval = sval->dyn_cast_initial_svalue ())
 	{
-	  const region2 *reg = init_sval->get_region ();
+	  const region *reg = init_sval->get_region ();
 	  /* Try recursing upwards (up to the base region for the cluster).  */
 	  if (!reg->base_region_p ())
-	    if (const region2 *parent_reg = reg->get_parent_region ())
+	    if (const region *parent_reg = reg->get_parent_region ())
 	      {
-		const svalue2 *parent_init_sval
+		const svalue *parent_init_sval
 		  = mgr->get_or_create_initial_value (parent_reg);
 		state_machine::state_t parent_state
 		  = get_state (parent_init_sval, ext_state);
@@ -379,16 +379,16 @@ sm_state_map2::get_state (const svalue2 *sval,
   return m_sm.get_default_state (sval);
 }
 
-/* Get the "origin" svalue2 for any state of SVAL.  */
+/* Get the "origin" svalue for any state of SVAL.  */
 
-const svalue2 *
-sm_state_map2::get_origin (const svalue2 *sval,
+const svalue *
+sm_state_map::get_origin (const svalue *sval,
 			   const extrinsic_state &ext_state) const
 {
   gcc_assert (sval);
 
 #if NULL_POINTER_TYPE_CONSOLIDATION
-  sval = canonicalize_svalue2 (sval, ext_state);
+  sval = canonicalize_svalue (sval, ext_state);
 #endif
 
   entry_t *slot
@@ -403,38 +403,22 @@ sm_state_map2::get_origin (const svalue2 *sval,
    the state came from ORIGIN.  */
 
 void
-sm_state_map2::set_state (region_model2 *model,
-			  const svalue2 *sval,
+sm_state_map::set_state (region_model *model,
+			  const svalue *sval,
 			  state_machine::state_t state,
-			  const svalue2 *origin,
+			  const svalue *origin,
 			  const extrinsic_state &ext_state)
 {
   if (model == NULL)
     return;
 
   /* Reject attempts to set state on UNKNOWN.  */
-  if (sval->get_kind () == svalue2::SK_UNKNOWN)
+  if (sval->get_kind () == svalue::SK_UNKNOWN)
     return;
 
-  equiv_class2 &ec = model->get_constraints2 ()->get_equiv_class2 (sval);
+  equiv_class &ec = model->get_constraints ()->get_equiv_class (sval);
   if (!set_state (ec, state, origin, ext_state))
     return;
-
-  // TODO:
-#if 0
-  /* Also do it for all svalues that are equal via non-cm, so that
-     e.g. (void *)&r and (foo *)&r transition together.  */
-  for (unsigned i = 0; i < model->get_num_svalues (); i++)
-    {
-      svalue_id other_sid = svalue_id::from_int (i);
-      if (other_sid == sid)
-	continue;
-
-      tristate eq = model->eval_condition_without_cm (sid, EQ_EXPR, other_sid);
-      if (eq.is_true ())
-	impl_set_state (other_sid, state, origin);
-    }
-#endif
 }
 
 /* Set the state of EC to STATE, recording that the state came from
@@ -442,13 +426,13 @@ sm_state_map2::set_state (region_model2 *model,
    Return true if any states of svalue_ids within EC changed.  */
 
 bool
-sm_state_map2::set_state (const equiv_class2 &ec,
+sm_state_map::set_state (const equiv_class &ec,
 			  state_machine::state_t state,
-			  const svalue2 *origin,
+			  const svalue *origin,
 			  const extrinsic_state &ext_state)
 {
   int i;
-  const svalue2 *sval;
+  const svalue *sval;
   bool any_changed = false;
   FOR_EACH_VEC_ELT (ec.m_vars, i, sval)
     any_changed |= impl_set_state (sval, state, origin, ext_state);
@@ -459,13 +443,13 @@ sm_state_map2::set_state (const equiv_class2 &ec,
    Return true if the state changed.  */
 
 bool
-sm_state_map2::impl_set_state (const svalue2 *sval,
+sm_state_map::impl_set_state (const svalue *sval,
 			       state_machine::state_t state,
-			       const svalue2 *origin,
+			       const svalue *origin,
 			       const extrinsic_state &ext_state)
 {
 #if NULL_POINTER_TYPE_CONSOLIDATION
-  sval = canonicalize_svalue2 (sval, ext_state);
+  sval = canonicalize_svalue (sval, ext_state);
 #endif
 
   if (get_state (sval, ext_state) == state)
@@ -486,7 +470,7 @@ sm_state_map2::impl_set_state (const svalue2 *sval,
 /* Set the "global" state within this state map to STATE.  */
 
 void
-sm_state_map2::set_global_state (state_machine::state_t state)
+sm_state_map::set_global_state (state_machine::state_t state)
 {
   m_global_state = state;
 }
@@ -494,7 +478,7 @@ sm_state_map2::set_global_state (state_machine::state_t state)
 /* Get the "global" state within this state map.  */
 
 state_machine::state_t
-sm_state_map2::get_global_state () const
+sm_state_map::get_global_state () const
 {
   return m_global_state;
 }
@@ -506,65 +490,13 @@ sm_state_map2::get_global_state () const
    not to this one.  */
 
 void
-sm_state_map2::purge_for_unknown_fncall (const exploded_graph &eg,
+sm_state_map::purge_for_unknown_fncall (const exploded_graph &eg,
 					 const gcall *call,
 					 tree fndecl,
-					 region_model2 *new_model,
-					 region_model2_context *ctxt)
+					 region_model *new_model,
+					 region_model_context *ctxt)
 {
   // TODO
-#if 0
-  logger * const logger = eg.get_logger ();
-  if (logger)
-    {
-      if (fndecl)
-	logger->log ("function %qE is unknown to checker %qs",
-		     fndecl, sm.get_name ());
-      else
-	logger->log ("unknown function pointer for checker %qs",
-		     sm.get_name ());
-    }
-
-  /* Purge any state for parms.  */
-  tree iter_param_types = NULL_TREE;
-  if (fndecl)
-    iter_param_types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
-  for (unsigned arg_idx = 0; arg_idx < gimple_call_num_args (call); arg_idx++)
-    {
-      /* Track expected param type, where available.  */
-      if (iter_param_types)
-	{
-	  tree param_type = TREE_VALUE (iter_param_types);
-	  gcc_assert (param_type);
-	  iter_param_types = TREE_CHAIN (iter_param_types);
-
-	  /* Don't purge state if it was passed as a const pointer
-	     e.g. for things like strlen (PTR).  */
-	  if (TREE_CODE (param_type) == POINTER_TYPE)
-	    if (TYPE_READONLY (TREE_TYPE (param_type)))
-	      continue;
-	}
-      tree parm = gimple_call_arg (call, arg_idx);
-      svalue_id parm_sid = new_model->get_rvalue (parm, ctxt);
-      set_state (new_model, parm_sid, 0, NULL);
-
-      /* Also clear sm-state from svalue_ids that are passed via a
-	 pointer.  */
-      if (TREE_CODE (parm) == ADDR_EXPR)
-	{
-	  tree pointee = TREE_OPERAND (parm, 0);
-	  svalue_id parm_sid = new_model->get_rvalue (pointee, ctxt);
-	  set_state (new_model, parm_sid, 0, svalue_id::null ());
-	}
-    }
-
-  /* Purge any state for any LHS.  */
-  if (tree lhs = gimple_call_lhs (call))
-    {
-      svalue_id lhs_sid = new_model->get_rvalue (lhs, ctxt);
-      set_state (new_model, lhs_sid, 0, svalue_id::null ());
-    }
-#endif
 }
 
 // FIXME:
@@ -573,8 +505,8 @@ sm_state_map2::purge_for_unknown_fncall (const exploded_graph &eg,
    using FIXME.  */
 
 void
-sm_state_map2::on_svalue2_leak (const svalue2 *sval,
-				impl_region_model2_context *ctxt)
+sm_state_map::on_svalue_leak (const svalue *sval,
+			      impl_region_model_context *ctxt)
 {
   if (state_machine::state_t state = get_state (sval, ctxt->m_ext_state))
     {
@@ -587,18 +519,18 @@ sm_state_map2::on_svalue2_leak (const svalue2 *sval,
 /* FIXME.  */
 
 void
-sm_state_map2::
-on_liveness_change (const svalue2_set &live_svalues,
-		    const region_model2 *model,
-		    impl_region_model2_context *ctxt)
+sm_state_map::
+on_liveness_change (const svalue_set &live_svalues,
+		    const region_model *model,
+		    impl_region_model_context *ctxt)
 {
-  hash_set <const svalue2 *> svals_to_unset;
+  hash_set <const svalue *> svals_to_unset;
 
   for (map_t::iterator iter = m_map.begin ();
        iter != m_map.end ();
        ++iter)
     {
-      const svalue2 *iter_sval = (*iter).first;
+      const svalue *iter_sval = (*iter).first;
       if (!iter_sval->live_p (live_svalues, model))
 	{
 	  svals_to_unset.add (iter_sval);
@@ -610,7 +542,7 @@ on_liveness_change (const svalue2_set &live_svalues,
 	}
     }
 
-  for (hash_set <const svalue2 *>::iterator iter = svals_to_unset.begin ();
+  for (hash_set <const svalue *>::iterator iter = svals_to_unset.begin ();
        iter != svals_to_unset.end (); ++iter)
     m_map.remove (*iter);
 }
@@ -619,7 +551,7 @@ on_liveness_change (const svalue2_set &live_svalues,
 /* Set the state of CHILD_SID to that of PARENT_SID.  */
 
 void
-sm_state_map2::on_inherited_svalue (svalue_id parent_sid,
+sm_state_map::on_inherited_svalue (svalue_id parent_sid,
 				   svalue_id child_sid)
 {
   state_machine::state_t state = get_state (parent_sid);
@@ -629,7 +561,7 @@ sm_state_map2::on_inherited_svalue (svalue_id parent_sid,
 /* Set the state of DST_SID to that of SRC_SID.  */
 
 void
-sm_state_map2::on_cast (svalue_id src_sid,
+sm_state_map::on_cast (svalue_id src_sid,
 		       svalue_id dst_sid)
 {
   state_machine::state_t state = get_state (src_sid);
@@ -641,18 +573,18 @@ sm_state_map2::on_cast (svalue_id src_sid,
 /* Purge state from SID (in response to a call to an unknown function).  */
 
 void
-sm_state_map2::on_unknown_change (const state_machine &sm,
-				  const svalue2 *sval,
+sm_state_map::on_unknown_change (const state_machine &sm,
+				  const svalue *sval,
 				  bool is_mutable,
 				  const extrinsic_state &ext_state)
 {
-  hash_set <const svalue2 *> svals_to_unset;
+  hash_set <const svalue *> svals_to_unset;
 
   for (map_t::iterator iter = m_map.begin ();
        iter != m_map.end ();
        ++iter)
     {
-      const svalue2 *key = (*iter).first;
+      const svalue *key = (*iter).first;
       entry_t e = (*iter).second;
       /* We only want to purge state for some states when things
 	 are mutable.  For example, in sm-malloc.cc, an on-stack ptr
@@ -663,11 +595,11 @@ sm_state_map2::on_unknown_change (const state_machine &sm,
 	svals_to_unset.add (key);
       /* If we have INIT_VAL(BASE_REG), then unset any INIT_VAL(REG)
 	 for REG within BASE_REG.  */
-      if (const initial_svalue2 *init_sval = sval->dyn_cast_initial_svalue2 ())
-	if (const initial_svalue2 *init_key = key->dyn_cast_initial_svalue2 ())
+      if (const initial_svalue *init_sval = sval->dyn_cast_initial_svalue ())
+	if (const initial_svalue *init_key = key->dyn_cast_initial_svalue ())
 	  {
-	    const region2 *changed_reg = init_sval->get_region ();
-	    const region2 *changed_key = init_key->get_region ();
+	    const region *changed_reg = init_sval->get_region ();
+	    const region *changed_key = init_key->get_region ();
 	    if (changed_key->get_base_region () == changed_reg)
 	      {
 		/* FIXME: better condition for the above?  */
@@ -676,7 +608,7 @@ sm_state_map2::on_unknown_change (const state_machine &sm,
 	  }
     }
 
-  for (hash_set <const svalue2 *>::iterator iter = svals_to_unset.begin ();
+  for (hash_set <const svalue *>::iterator iter = svals_to_unset.begin ();
        iter != svals_to_unset.end (); ++iter)
     {
       impl_set_state (*iter, (state_machine::state_t)0, NULL, ext_state);
@@ -686,7 +618,7 @@ sm_state_map2::on_unknown_change (const state_machine &sm,
 /* Assert that this object is sane.  */
 #if 0
 void
-sm_state_map2::validate (const state_machine &sm,
+sm_state_map::validate (const state_machine &sm,
 			int num_svalues) const
 {
   /* Skip this in a release build.  */
@@ -712,15 +644,15 @@ sm_state_map2::validate (const state_machine &sm,
 
 #if NULL_POINTER_TYPE_CONSOLIDATION
 
-const svalue2 *
-sm_state_map2::canonicalize_svalue2 (const svalue2 *sval,
+const svalue *
+sm_state_map::canonicalize_svalue (const svalue *sval,
 				     const extrinsic_state &ext_state)
 {
-  region_model2_manager *mgr = ext_state.get_model_manager ();
+  region_model_manager *mgr = ext_state.get_model_manager ();
   if (mgr && sval->get_type () && POINTER_TYPE_P (sval->get_type ()))
     if (tree cst = sval->maybe_get_constant ())
       if (zerop (cst))
-	return mgr->get_or_create_constant_svalue2 (null_pointer_node);
+	return mgr->get_or_create_constant_svalue (null_pointer_node);
 
   return sval;
 }
@@ -732,33 +664,33 @@ sm_state_map2::canonicalize_svalue2 (const svalue2 *sval,
 /* program_state's ctor.  */
 
 program_state::program_state (const extrinsic_state &ext_state)
-: m_region_model2 (NULL),
-  m_checker_states2 (ext_state.get_num_checkers ()),
+: m_region_model (NULL),
+  m_checker_states (ext_state.get_num_checkers ()),
   m_valid (true)
 {
-  engine2 *eng2 = ext_state.get_engine2 ();
-  region_model2_manager *mgr = eng2->get_model_manager ();
-  m_region_model2 = new region_model2 (mgr);
+  engine *eng = ext_state.get_engine ();
+  region_model_manager *mgr = eng->get_model_manager ();
+  m_region_model = new region_model (mgr);
   const int num_states = ext_state.get_num_checkers ();
   for (int i = 0; i < num_states; i++)
     {
-      sm_state_map2 *sm = new sm_state_map2 (ext_state.get_sm (i), i);
-      m_checker_states2.quick_push (sm);
+      sm_state_map *sm = new sm_state_map (ext_state.get_sm (i), i);
+      m_checker_states.quick_push (sm);
     }
 }
 
 /* program_state's copy ctor.  */
 
 program_state::program_state (const program_state &other)
-: m_region_model2 (NULL),
-  m_checker_states2 (other.m_checker_states2.length ()),
+: m_region_model (NULL),
+  m_checker_states (other.m_checker_states.length ()),
   m_valid (true)
 {
-  m_region_model2 = new region_model2 (*other.m_region_model2);
+  m_region_model = new region_model (*other.m_region_model);
   int i;
-  sm_state_map2 *smap2;
-  FOR_EACH_VEC_ELT (other.m_checker_states2, i, smap2)
-    m_checker_states2.quick_push (smap2->clone ());
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (other.m_checker_states, i, smap)
+    m_checker_states.quick_push (smap->clone ());
 }
 
 /* program_state's assignment operator.  */
@@ -766,37 +698,37 @@ program_state::program_state (const program_state &other)
 program_state&
 program_state::operator= (const program_state &other)
 {
-  delete m_region_model2;
-  m_region_model2 = new region_model2 (*other.m_region_model2);
+  delete m_region_model;
+  m_region_model = new region_model (*other.m_region_model);
 
   int i;
-  sm_state_map2 *smap2;
-  FOR_EACH_VEC_ELT (m_checker_states2, i, smap2)
-    delete smap2;
-  m_checker_states2.truncate (0);
-  gcc_assert (m_checker_states2.space (other.m_checker_states2.length ()));
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_checker_states, i, smap)
+    delete smap;
+  m_checker_states.truncate (0);
+  gcc_assert (m_checker_states.space (other.m_checker_states.length ()));
 
-  FOR_EACH_VEC_ELT (other.m_checker_states2, i, smap2)
-    m_checker_states2.quick_push (smap2->clone ());
+  FOR_EACH_VEC_ELT (other.m_checker_states, i, smap)
+    m_checker_states.quick_push (smap->clone ());
 
   m_valid = other.m_valid;
 
   return *this;
 }
 
-#if __cplusplus >= 201103
+#if __cplusplus >= 01103
 /* Move constructor for program_state (when building with C++11).  */
 program_state::program_state (program_state &&other)
-: m_region_model2 (other.m_region_model2),
-  m_checker_states2 (other.m_checker_states2.length ())
+: m_region_model (other.m_region_model),
+  m_checker_states (other.m_checker_states.length ())
 {
-  other.m_region_model2 = NULL;
+  other.m_region_model = NULL;
 
   int i;
-  sm_state_map2 *smap2;
-  FOR_EACH_VEC_ELT (other.m_checker_states2, i, smap2)
-    m_checker_states2.quick_push (smap2);
-  other.m_checker_states2.truncate (0);
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (other.m_checker_states, i, smap)
+    m_checker_states.quick_push (smap);
+  other.m_checker_states.truncate (0);
 
   m_valid = other.m_valid;
 }
@@ -806,7 +738,7 @@ program_state::program_state (program_state &&other)
 
 program_state::~program_state ()
 {
-  delete m_region_model2;
+  delete m_region_model;
 }
 
 /* Generate a hash value for this program_state.  */
@@ -817,12 +749,12 @@ program_state::hash () const
   hashval_t result = 0;
 
   // TODO:
-  //result ^= m_region_model2->hash ();
+  //result ^= m_region_model->hash ();
 
   int i;
-  sm_state_map2 *smap2;
-  FOR_EACH_VEC_ELT (m_checker_states2, i, smap2)
-    result ^= smap2->hash ();
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_checker_states, i, smap)
+    result ^= smap->hash ();
 
   return result;
 }
@@ -835,13 +767,13 @@ program_state::hash () const
 bool
 program_state::operator== (const program_state &other) const
 {
-  if (!(*m_region_model2 == *other.m_region_model2))
+  if (!(*m_region_model == *other.m_region_model))
     return false;
 
   int i;
-  sm_state_map2 *smap2;
-  FOR_EACH_VEC_ELT (m_checker_states2, i, smap2)
-    if (!(*smap2 == *other.m_checker_states2[i]))
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_checker_states, i, smap)
+    if (!(*smap == *other.m_checker_states[i]))
       return false;
 
   gcc_checking_assert (hash () == other.hash ());
@@ -856,17 +788,17 @@ program_state::print (const extrinsic_state &ext_state,
 		      pretty_printer *pp) const
 {
   pp_printf (pp, "rmodel: ");
-  m_region_model2->dump_to_pp (pp, true, false);
+  m_region_model->dump_to_pp (pp, true, false);
   pp_newline (pp);
 
   int i;
-  sm_state_map2 *smap2;
-  FOR_EACH_VEC_ELT (m_checker_states2, i, smap2)
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_checker_states, i, smap)
     {
-      if (!smap2->is_empty_p ())
+      if (!smap->is_empty_p ())
 	{
 	  pp_printf (pp, "%s: ", ext_state.get_name (i));
-	  smap2->print (m_region_model2, true, false, pp);
+	  smap->print (m_region_model, true, false, pp);
 	  pp_newline (pp);
 	}
     }
@@ -890,29 +822,29 @@ program_state::dump_to_pp (const extrinsic_state &ext_state,
   if (!multiline)
     pp_string (pp, "{");
   {
-    pp_printf (pp, "rmodel2:");
+    pp_printf (pp, "rmodel:");
     if (multiline)
       pp_newline (pp);
     else
       pp_string (pp, " {");
-    m_region_model2->dump_to_pp (pp, true, multiline);
-    //m_region_model2->summarize_to_pp (pp, true);
+    m_region_model->dump_to_pp (pp, true, multiline);
+    //m_region_model->summarize_to_pp (pp, true);
     if (!multiline)
       pp_string (pp, "}");
   }
 
   int i;
-  sm_state_map2 *smap2;
-  FOR_EACH_VEC_ELT (m_checker_states2, i, smap2)
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (m_checker_states, i, smap)
     {
-      if (!smap2->is_empty_p ())
+      if (!smap->is_empty_p ())
 	{
 	  if (!multiline)
 	    pp_string (pp, " {");
 	  pp_printf (pp, "%s: ", ext_state.get_name (i));
 	  if (multiline)
 	    pp_newline (pp);
-	  smap2->print (m_region_model2, true, multiline, pp);
+	  smap->print (m_region_model, true, multiline, pp);
 	  if (!multiline)
 	    pp_string (pp, "}");
 	}
@@ -962,8 +894,8 @@ program_state::to_json () const
 {
   json::object *obj = new json::object ();
 #if 0
-  if (m_region_model2
-    obj->set ("region_model2", m_region_model2->to_json ());
+  if (m_region_model
+    obj->set ("region_model", m_region_model->to_json ());
 #endif
   return obj;
 }
@@ -972,8 +904,8 @@ void
 program_state::push_frame (const extrinsic_state &ext_state,
 			   function *fun)
 {
-  region_model2_context *ctxt = NULL; // FIXME
-  m_region_model2->push_frame (fun, NULL, ctxt);
+  region_model_context *ctxt = NULL; // FIXME
+  m_region_model->push_frame (fun, NULL, ctxt);
 }
 
 /* FIXME.  */
@@ -981,7 +913,7 @@ program_state::push_frame (const extrinsic_state &ext_state,
 function *
 program_state::get_current_function () const
 {
-  return m_region_model2->get_current_function ();
+  return m_region_model->get_current_function ();
 }
 
 /* Determine if following edge SUCC from ENODE is valid within the graph EG
@@ -1013,23 +945,23 @@ program_state::on_edge (exploded_graph &eg,
      Adding the relevant conditions for the edge could also trigger
      sm-state transitions (e.g. transitions due to ptrs becoming known
      to be NULL or non-NULL) */
-  impl_region_model2_context ctxt (eg, &enode,
+  impl_region_model_context ctxt (eg, &enode,
 				   &enode.get_state (),
 				   this,
 				   last_stmt);
-  if (!m_region_model2->maybe_update_for_edge (*succ,
+  if (!m_region_model->maybe_update_for_edge (*succ,
 					       last_stmt,
 					       &ctxt))
     {
       logger * const logger = eg.get_logger ();
       if (logger)
 	logger->log ("edge to SN: %i is impossible"
-		     " due to region_model2 constraints",
+		     " due to region_model constraints",
 		     succ->m_dest->m_index);
       return false;
     }
 
-  program_state::detect_leaks2 (enode.get_state (), *this,
+  program_state::detect_leaks (enode.get_state (), *this,
 				NULL, eg.get_ext_state (),
 				&ctxt);
 
@@ -1054,21 +986,21 @@ program_state::prune_for_point (exploded_graph &eg,
   if (!fun)
     return *this;
 
-  gcc_assert (m_region_model2);
+  gcc_assert (m_region_model);
 
   program_state new_state (*this);
 
-  purge_stats2 stats;
+  purge_stats stats;
 
   const state_purge_map *pm = eg.get_purge_map ();
   if (pm)
     {
       unsigned num_ssas_purged = 0;
-      auto_vec<const decl_region2 *> ssa_name_regs;
-      new_state.m_region_model2->get_ssa_name_regions_for_current_frame
+      auto_vec<const decl_region *> ssa_name_regs;
+      new_state.m_region_model->get_ssa_name_regions_for_current_frame
 	(&ssa_name_regs);
       unsigned i;
-      const decl_region2 *reg;
+      const decl_region *reg;
       FOR_EACH_VEC_ELT (ssa_name_regs, i, reg)
 	{
 	  tree ssa_name = reg->get_decl ();
@@ -1087,9 +1019,9 @@ program_state::prune_for_point (exploded_graph &eg,
 		 is reported at the point of overwrite, rather than having
 		 temporaries keep the value reachable until the frame is
 		 popped.  */
-	      const svalue2 *sval
-		= new_state.m_region_model2->get_store_value (reg);
-	      if (!new_state.can_purge_p2 (eg.get_ext_state (), sval)
+	      const svalue *sval
+		= new_state.m_region_model->get_store_value (reg);
+	      if (!new_state.can_purge_p (eg.get_ext_state (), sval)
 		  && SSA_NAME_VAR (ssa_name))
 		{
 		  /* (currently only state maps can keep things
@@ -1100,7 +1032,7 @@ program_state::prune_for_point (exploded_graph &eg,
 		  continue;
 		}
 
-	      new_state.m_region_model2->purge_region (reg);
+	      new_state.m_region_model->purge_region (reg);
 	      num_ssas_purged++;
 	      // TODO: update stats
 	      if (logger)
@@ -1113,11 +1045,11 @@ program_state::prune_for_point (exploded_graph &eg,
       if (num_ssas_purged > 0)
 	{
 	  // TODO: which enode to use, if any?
-	  impl_region_model2_context ctxt (eg, enode_for_diag,
+	  impl_region_model_context ctxt (eg, enode_for_diag,
 					   this,
 					   &new_state,
 					   point.get_stmt ());
-	  detect_leaks2 (*this, new_state, NULL, eg.get_ext_state (), &ctxt);
+	  detect_leaks (*this, new_state, NULL, eg.get_ext_state (), &ctxt);
 	}
     }
 
@@ -1128,12 +1060,12 @@ program_state::prune_for_point (exploded_graph &eg,
      relative to another state.  */
 #if 0
   // TODO: which enode to use, if any?
-  impl_region_model2_context ctxt (eg, NULL,
+  impl_region_model_context ctxt (eg, NULL,
 				   this,
 				   &new_state,
 				   change,
 				   NULL);
-  new_state.m_region_model2->purge_unused_svalues (&stats, &ctxt);
+  new_state.m_region_model->purge_unused_svalues (&stats, &ctxt);
   if (logger)
     {
       logger->log ("num svalues purged: %i", stats.m_num_svalues);
@@ -1144,7 +1076,7 @@ program_state::prune_for_point (exploded_graph &eg,
     }
 #endif
 
-  new_state.m_region_model2->canonicalize ();
+  new_state.m_region_model->canonicalize ();
 
   return new_state;
 }
@@ -1152,10 +1084,10 @@ program_state::prune_for_point (exploded_graph &eg,
 /* FIXME.  */
 
 tree
-program_state::get_representative_tree2 (const svalue2 *sval) const
+program_state::get_representative_tree (const svalue *sval) const
 {
-  gcc_assert (m_region_model2);
-  return m_region_model2->get_representative_tree (sval);
+  gcc_assert (m_region_model);
+  return m_region_model->get_representative_tree (sval);
 }
 
 /* Attempt to merge this state with OTHER, both using EXT_STATE.
@@ -1170,29 +1102,29 @@ program_state::can_merge_with_p (const program_state &other,
 				 program_state *out) const
 {
   gcc_assert (out);
-  gcc_assert (m_region_model2);
+  gcc_assert (m_region_model);
 
   /* Early reject if there are sm-differences between the states.  */
   int i;
-  sm_state_map2 *smap;
-  FOR_EACH_VEC_ELT (out->m_checker_states2, i, smap)
-    if (*m_checker_states2[i] != *other.m_checker_states2[i])
+  sm_state_map *smap;
+  FOR_EACH_VEC_ELT (out->m_checker_states, i, smap)
+    if (*m_checker_states[i] != *other.m_checker_states[i])
       return false;
 
   /* Attempt to merge the region_models.  */
-  if (!m_region_model2->can_merge_with_p (*other.m_region_model2,
+  if (!m_region_model->can_merge_with_p (*other.m_region_model,
 					  point,
-					  out->m_region_model2))
+					  out->m_region_model))
     return false;
 
   /* Copy m_checker_states to OUT.  */
-  FOR_EACH_VEC_ELT (out->m_checker_states2, i, smap)
+  FOR_EACH_VEC_ELT (out->m_checker_states, i, smap)
     {
       delete smap;
-      out->m_checker_states2[i] = m_checker_states2[i]->clone ();
+      out->m_checker_states[i] = m_checker_states[i]->clone ();
     }
 
-  out->m_region_model2->canonicalize ();
+  out->m_region_model->canonicalize ();
 
   return true;
 }
@@ -1207,21 +1139,21 @@ program_state::validate (const extrinsic_state &ext_state) const
   return;
 #endif
 
-  gcc_assert (m_checker_states2.length () == ext_state.get_num_checkers ());
+  gcc_assert (m_checker_states.length () == ext_state.get_num_checkers ());
 }
 
 static void
-log_set_of_svalue2s (logger *logger, const char *name,
-		     const svalue2_set &set)
+log_set_of_svalues (logger *logger, const char *name,
+		     const svalue_set &set)
 {
   logger->log (name);
   logger->inc_indent ();
-  for (svalue2_set::iterator iter = set.begin ();
+  for (svalue_set::iterator iter = set.begin ();
        iter != set.end (); ++iter)
     {
       logger->start_log_line ();
       pretty_printer *pp = logger->get_printer ();
-      const svalue2 *sval = (*iter);
+      const svalue *sval = (*iter);
       pp_pointer (pp, sval);
       pp_string (pp, ": ");
       sval->dump_to_pp (pp, false);
@@ -1233,11 +1165,11 @@ log_set_of_svalue2s (logger *logger, const char *name,
 /* FIXME.  */
 // FIXME: do this at each fine-grained state, not just at edges
 void
-program_state::detect_leaks2 (const program_state &src_state,
+program_state::detect_leaks (const program_state &src_state,
 			      const program_state &dest_state,
-			      const svalue2 *extra_sval,
+			      const svalue *extra_sval,
 			      const extrinsic_state &ext_state,
-			      region_model2_context *ctxt)
+			      region_model_context *ctxt)
 {
   logger *logger = ext_state.get_logger ();
   LOG_SCOPE (logger);
@@ -1262,24 +1194,24 @@ program_state::detect_leaks2 (const program_state &src_state,
     }
 
   /* Get svalues reachable from each of src_state and dst_state.  */
-  svalue2_set src_svalues;
-  svalue2_set dest_svalues;
-  src_state.m_region_model2->get_reachable_svalues (&src_svalues, NULL);
-  dest_state.m_region_model2->get_reachable_svalues (&dest_svalues,
+  svalue_set src_svalues;
+  svalue_set dest_svalues;
+  src_state.m_region_model->get_reachable_svalues (&src_svalues, NULL);
+  dest_state.m_region_model->get_reachable_svalues (&dest_svalues,
 						     extra_sval);
 
   if (logger)
     {
-      log_set_of_svalue2s (logger, "src_state reachable svalues:", src_svalues);
-      log_set_of_svalue2s (logger, "dest_state reachable svalues:",
+      log_set_of_svalues (logger, "src_state reachable svalues:", src_svalues);
+      log_set_of_svalues (logger, "dest_state reachable svalues:",
 			   dest_svalues);
     }
 
-  for (svalue2_set::iterator iter = src_svalues.begin ();
+  for (svalue_set::iterator iter = src_svalues.begin ();
        iter != src_svalues.end (); ++iter)
     {
-      const svalue2 *sval = (*iter);
-      if (!sval->live_p (dest_svalues, dest_state.m_region_model2))
+      const svalue *sval = (*iter);
+      if (!sval->live_p (dest_svalues, dest_state.m_region_model))
 	{
 #if 0
 	  pretty_printer pp1, pp2, pp3;
@@ -1294,188 +1226,19 @@ program_state::detect_leaks2 (const program_state &src_state,
 		 pp_formatted_text (&pp2),
 		 pp_formatted_text (&pp3));
 #endif
-	  ctxt->on_svalue2_leak (sval);
+	  ctxt->on_svalue_leak (sval);
 
 	}
     }
 
   /* Purge dead svals from sm-state.  */
-  ctxt->on_liveness_change (dest_svalues, dest_state.m_region_model2);
+  ctxt->on_liveness_change (dest_svalues, dest_state.m_region_model);
 
   /* Purge dead svals from constraints.  */
-  dest_state.m_region_model2->get_constraints2 ()->on_liveness_change
-    (dest_svalues, dest_state.m_region_model2);
-}
-
-#if 0
-/* Dump this sm_change to PP.  */
-
-void
-state_change::sm_change::dump (pretty_printer *pp,
-			       const extrinsic_state &ext_state) const
-{
-  const state_machine &sm = get_sm (ext_state);
-  pp_string (pp, "(");
-  m_new_sid.print (pp);
-  pp_printf (pp, ": %s: %qs -> %qs)",
-	     sm.get_name (),
-	     sm.get_state_name (m_old_state),
-	     sm.get_state_name (m_new_state));
-}
-
-/* Remap all svalue_ids in this change according to MAP.  */
-
-void
-state_change::sm_change::remap_svalue_ids (const svalue_id_map &map)
-{
-  map.update (&m_new_sid);
-}
-
-/* Purge any svalue_ids >= FIRST_UNUSED_SID.
-   Return the number of states that were purged.  */
-
-int
-state_change::sm_change::on_svalue_purge (svalue_id first_unused_sid)
-{
-  if (m_new_sid.as_int () >= first_unused_sid.as_int ())
-    {
-      m_new_sid = svalue_id::null ();
-      return 1;
-    }
-
-  return 0;
-}
-
-/* Assert that this object is sane.  */
-
-void
-state_change::sm_change::validate (const program_state &new_state,
-				   const extrinsic_state &ext_state) const
-{
-  gcc_assert ((unsigned)m_sm_idx < ext_state.get_num_checkers ());
-  const state_machine &sm = ext_state.get_sm (m_sm_idx);
-  sm.validate (m_old_state);
-  sm.validate (m_new_state);
-  m_new_sid.validate (*new_state.m_region_model);
-}
-
-/* state_change's ctor.  */
-
-state_change::state_change ()
-{
-}
-
-/* state_change's copy ctor.  */
-
-state_change::state_change (const state_change &other)
-: m_sm_changes (other.m_sm_changes.length ())
-{
-  unsigned i;
-  sm_change *change;
-  FOR_EACH_VEC_ELT (other.m_sm_changes, i, change)
-    m_sm_changes.quick_push (*change);
-}
-
-/* Record a state-machine state change.  */
-
-void
-state_change::add_sm_change (int sm_idx,
-			     svalue_id new_sid,
-			     state_machine::state_t old_state,
-			     state_machine::state_t new_state)
-{
-  m_sm_changes.safe_push (sm_change (sm_idx,
-				     new_sid,
-				     old_state, new_state));
-}
-
-/* Return true if SID (in the new state) was affected by any
-   sm-state changes.  */
-
-bool
-state_change::affects_p (svalue_id sid) const
-{
-  unsigned i;
-  sm_change *change;
-  FOR_EACH_VEC_ELT (m_sm_changes, i, change)
-    {
-      if (sid == change->m_new_sid)
-	return true;
-    }
-  return false;
-}
-
-/* Dump this state_change to PP.  */
-
-void
-state_change::dump (pretty_printer *pp,
-		    const extrinsic_state &ext_state) const
-{
-  unsigned i;
-  sm_change *change;
-  FOR_EACH_VEC_ELT (m_sm_changes, i, change)
-    {
-      if (i > 0)
-	pp_string (pp, ", ");
-      change->dump (pp, ext_state);
-    }
-}
-
-/* Dump this state_change to stderr.  */
-
-void
-state_change::dump (const extrinsic_state &ext_state) const
-{
-  pretty_printer pp;
-  pp_show_color (&pp) = pp_show_color (global_dc->printer);
-  pp.buffer->stream = stderr;
-  dump (&pp, ext_state);
-  pp_newline (&pp);
-  pp_flush (&pp);
-}
-
-/* Remap all svalue_ids in this state_change according to MAP.  */
-
-void
-state_change::remap_svalue_ids (const svalue_id_map &map)
-{
-  unsigned i;
-  sm_change *change;
-  FOR_EACH_VEC_ELT (m_sm_changes, i, change)
-    change->remap_svalue_ids (map);
-}
-
-/* Purge any svalue_ids >= FIRST_UNUSED_SID.
-   Return the number of states that were purged.  */
-
-int
-state_change::on_svalue_purge (svalue_id first_unused_sid)
-{
-  int result = 0;
-  unsigned i;
-  sm_change *change;
-  FOR_EACH_VEC_ELT (m_sm_changes, i, change)
-    result += change->on_svalue_purge (first_unused_sid);
-  return result;
+  dest_state.m_region_model->get_constraints ()->on_liveness_change
+    (dest_svalues, dest_state.m_region_model);
 }
 
-/* Assert that this object is sane.  */
-
-void
-state_change::validate (const program_state &new_state,
-			const extrinsic_state &ext_state) const
-{
-  /* Skip this in a release build.  */
-#if !CHECKING_P
-  return;
-#endif
-  unsigned i;
-  sm_change *change;
-  FOR_EACH_VEC_ELT (m_sm_changes, i, change)
-    change->validate (new_state, ext_state);
-}
-#endif
-
 #if CHECKING_P
 
 namespace selftest {
@@ -1513,133 +1276,6 @@ test_sm_state_map ()
   tree y = build_global_decl ("y", integer_type_node);
   tree z = build_global_decl ("z", integer_type_node);
 
-  // TODO: coverage for purging
-}
-
-/* Verify that program_state::dump_to_pp works as expected.  */
-
-static void
-test_program_state_dumping ()
-{
-}
-
-/* Verify that program_state::dump_to_pp works for string literals.  */
-
-static void
-test_program_state_dumping_2 ()
-{
-}
-
-/* Verify that program_states with identical sm-state can be merged,
-   and that the merged program_state preserves the sm-state.  */
-
-static void
-test_program_state_merging ()
-{
-  program_point point (program_point::origin ());
-
-  /* Create a program_state for a global ptr "p" that has
-     malloc sm-state, pointing to a region on the heap.  */
-  tree p = build_global_decl ("p", ptr_type_node);
-
-  auto_delete_vec <state_machine> checkers;
-  checkers.safe_push (make_malloc_state_machine (NULL));
-  extrinsic_state ext_state (checkers);
-
-  program_state s0 (ext_state);
-#if 0
-  impl_region_model_context ctxt (&s0, NULL, ext_state);
-
-  region_model *model0 = s0.m_region_model;
-  region_id new_rid = model0->add_new_malloc_region ();
-  svalue_id ptr_sid
-      = model0->get_or_create_ptr_svalue (ptr_type_node, new_rid);
-  model0->set_value (model0->get_lvalue (p, &ctxt),
-		     ptr_sid, &ctxt);
-  sm_state_map *smap = s0.m_checker_states[0];
-  const state_machine::state_t TEST_STATE = 3;
-  smap->impl_set_state (ptr_sid, TEST_STATE, svalue_id::null ());
-  ASSERT_EQ (smap->get_state (ptr_sid), TEST_STATE);
-
-  model0->canonicalize (&ctxt);
-
-  /* Verify that canonicalization preserves sm-state.  */
-  ASSERT_EQ (smap->get_state (model0->get_rvalue (p, NULL)), TEST_STATE);
-
-  /* Make a copy of the program_state.  */
-  program_state s1 (s0);
-  ASSERT_EQ (s0, s1);
-
-  /* We have two identical states with "p" pointing to a heap region
-     with the given sm-state.
-     They ought to be mergeable, preserving the sm-state.  */
-  program_state merged (ext_state);
-  ASSERT_TRUE (s0.can_merge_with_p (s1, ext_state, point, &merged));
-  merged.validate (ext_state);
-
-  /* Verify that the merged state has the sm-state for "p".  */
-  region_model *merged_model = merged.m_region_model;
-  sm_state_map *merged_smap = merged.m_checker_states[0];
-  ASSERT_EQ (merged_smap->get_state (merged_model->get_rvalue (p, NULL)),
-	     TEST_STATE);
-
-  /* Try canonicalizing.  */
-  impl_region_model_context merged_ctxt (&merged, NULL, ext_state);
-  merged.m_region_model->canonicalize (&merged_ctxt);
-  merged.validate (ext_state);
-
-  /* Verify that the merged state still has the sm-state for "p".  */
-  ASSERT_EQ (merged_smap->get_state (merged_model->get_rvalue (p, NULL)),
-	     TEST_STATE);
-
-  /* After canonicalization, we ought to have equality with the inputs.  */
-  ASSERT_EQ (s0, merged);
-#endif
-}
-
-/* Verify that program_states with different global-state in an sm-state
-   can't be merged.  */
-
-static void
-test_program_state_merging_2 ()
-{
-  program_point point (program_point::origin ());
-  auto_delete_vec <state_machine> checkers;
-  checkers.safe_push (make_signal_state_machine (NULL));
-  extrinsic_state ext_state (checkers);
-
-  program_state s0 (ext_state);
-  {
-    sm_state_map2 *smap0 = s0.m_checker_states2[0];
-    const state_machine::state_t TEST_STATE_0 = 0;
-    smap0->set_global_state (TEST_STATE_0);
-    ASSERT_EQ (smap0->get_global_state (), TEST_STATE_0);
-  }
-
-  program_state s1 (ext_state);
-  {
-    sm_state_map2 *smap1 = s1.m_checker_states2[0];
-    const state_machine::state_t TEST_STATE_1 = 1;
-    smap1->set_global_state (TEST_STATE_1);
-    ASSERT_EQ (smap1->get_global_state (), TEST_STATE_1);
-  }
-
-  ASSERT_NE (s0, s1);
-
-  /* They ought to not be mergeable.  */
-  program_state merged (ext_state);
-  ASSERT_FALSE (s0.can_merge_with_p (s1, ext_state, point, &merged));
-}
-
-/* Tests for sm_state_map2.  */
-
-static void
-test_sm_state_map2 ()
-{
-  tree x = build_global_decl ("x", integer_type_node);
-  tree y = build_global_decl ("y", integer_type_node);
-  tree z = build_global_decl ("z", integer_type_node);
-
   state_machine *sm = make_malloc_state_machine (NULL);
   auto_delete_vec <state_machine> checkers;
   checkers.safe_push (sm);
@@ -1647,13 +1283,13 @@ test_sm_state_map2 ()
 
   /* Test setting states on svalue_id instances directly.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    const svalue2 *x_sval = model.get_rvalue (x, NULL);
-    const svalue2 *y_sval = model.get_rvalue (y, NULL);
-    const svalue2 *z_sval = model.get_rvalue (z, NULL);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    const svalue *x_sval = model.get_rvalue (x, NULL);
+    const svalue *y_sval = model.get_rvalue (y, NULL);
+    const svalue *z_sval = model.get_rvalue (z, NULL);
 
-    sm_state_map2 map (*sm, 0);
+    sm_state_map map (*sm, 0);
     ASSERT_TRUE (map.is_empty_p ());
     ASSERT_EQ (map.get_state (x_sval, ext_state), 0);
 
@@ -1673,13 +1309,13 @@ test_sm_state_map2 ()
 
   /* Test setting states via equivalence classes.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    const svalue2 *x_sval = model.get_rvalue (x, NULL);
-    const svalue2 *y_sval = model.get_rvalue (y, NULL);
-    const svalue2 *z_sval = model.get_rvalue (z, NULL);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    const svalue *x_sval = model.get_rvalue (x, NULL);
+    const svalue *y_sval = model.get_rvalue (y, NULL);
+    const svalue *z_sval = model.get_rvalue (z, NULL);
 
-    sm_state_map2 map (*sm, 0);
+    sm_state_map map (*sm, 0);
     ASSERT_TRUE (map.is_empty_p ());
     ASSERT_EQ (map.get_state (x_sval, ext_state), 0);
     ASSERT_EQ (map.get_state (y_sval, ext_state), 0);
@@ -1697,14 +1333,14 @@ test_sm_state_map2 ()
 
   /* Test equality and hashing.  */
   {
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    const svalue2 *y_sval = model.get_rvalue (y, NULL);
-    const svalue2 *z_sval = model.get_rvalue (z, NULL);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    const svalue *y_sval = model.get_rvalue (y, NULL);
+    const svalue *z_sval = model.get_rvalue (z, NULL);
 
-    sm_state_map2 map0 (*sm, 0);
-    sm_state_map2 map1 (*sm, 0);
-    sm_state_map2 map2 (*sm, 0);
+    sm_state_map map0 (*sm, 0);
+    sm_state_map map1 (*sm, 0);
+    sm_state_map map2 (*sm, 0);
 
     ASSERT_EQ (map0.hash (), map1.hash ());
     ASSERT_EQ (map0, map1);
@@ -1721,18 +1357,18 @@ test_sm_state_map2 ()
 
   /* Equality and hashing shouldn't depend on ordering.  */
   {
-    sm_state_map2 map0 (*sm, 0);
-    sm_state_map2 map1 (*sm, 0);
-    sm_state_map2 map2 (*sm, 0);
+    sm_state_map map0 (*sm, 0);
+    sm_state_map map1 (*sm, 0);
+    sm_state_map map2 (*sm, 0);
 
     ASSERT_EQ (map0.hash (), map1.hash ());
     ASSERT_EQ (map0, map1);
 
-    region_model2_manager mgr;
-    region_model2 model (&mgr);
-    const svalue2 *x_sval = model.get_rvalue (x, NULL);
-    const svalue2 *y_sval = model.get_rvalue (y, NULL);
-    const svalue2 *z_sval = model.get_rvalue (z, NULL);
+    region_model_manager mgr;
+    region_model model (&mgr);
+    const svalue *x_sval = model.get_rvalue (x, NULL);
+    const svalue *y_sval = model.get_rvalue (y, NULL);
+    const svalue *z_sval = model.get_rvalue (z, NULL);
 
     map1.impl_set_state (x_sval, 2, NULL, ext_state);
     map1.impl_set_state (y_sval, 3, NULL, ext_state);
@@ -1752,7 +1388,7 @@ test_sm_state_map2 ()
 /* Verify that program_state::dump_to_pp works as expected.  */
 
 static void
-test_program_state2_dumping ()
+test_program_state_dumping ()
 {
 #if 0
   /* Create a program_state for a global ptr "p" that has
@@ -1767,13 +1403,13 @@ test_program_state2_dumping ()
   extrinsic_state ext_state (checkers);
 
   program_state s (ext_state);
-  region_model2 *model = s.m_region_model;
+  region_model *model = s.m_region_model;
   region_id new_rid = model->add_new_malloc_region ();
   svalue_id ptr_sid
       = model->get_or_create_ptr_svalue (ptr_type_node, new_rid);
   model->set_value (model->get_lvalue (p, NULL),
 		    ptr_sid, NULL);
-  sm_state_map2 *smap = s.m_checker_states2[0];
+  sm_state_map *smap = s.m_checker_states[0];
 
   smap->impl_set_state (ptr_sid, UNCHECKED_STATE, svalue_id::null ());
   ASSERT_EQ (smap->get_state (ptr_sid), UNCHECKED_STATE);
@@ -1783,28 +1419,28 @@ test_program_state2_dumping ()
      "rmodel: r0: {kind: `root', parent: null, sval: null}\n"
      "|-heap: r1: {kind: `heap', parent: r0, sval: sv0}\n"
      "|  |: sval: sv0: {poisoned: uninit}\n"
-     "|  `-r2: {kind: `symbolic', parent: r1, sval: null, possibly_null: true}\n"
+     "|  `-r: {kind: `symbolic', parent: r1, sval: null, possibly_null: true}\n"
      "`-globals: r3: {kind: `globals', parent: r0, sval: null, map: {`p': r4}}\n"
      "  `-`p': r4: {kind: `primitive', parent: r3, sval: sv1, type: `void *'}\n"
-     "    |: sval: sv1: {type: `void *', &r2}\n"
+     "    |: sval: sv1: {type: `void *', &r}\n"
      "    |: type: `void *'\n"
      "svalues:\n"
      "  sv0: {poisoned: uninit}\n"
-     "  sv1: {type: `void *', &r2}\n"
+     "  sv1: {type: `void *', &r}\n"
      "constraint manager:\n"
      "  equiv classes:\n"
      "  constraints:\n"
      "malloc: {sv1: unchecked (`p')}\n");
 
   ASSERT_DUMP_EQ (s, ext_state, true,
-		  "rmodel: p: &r2 malloc: {sv1: unchecked (`p')}");
+		  "rmodel: p: &r malloc: {sv1: unchecked (`p')}");
 #endif
 }
 
 /* Verify that program_state::dump_to_pp works for string literals.  */
 
 static void
-test_program_state2_dumping_2 ()
+test_program_state_dumping_2 ()
 {
 #if 0
   /* Create a program_state for a global ptr "p" that points to
@@ -1852,7 +1488,7 @@ test_program_state2_dumping_2 ()
    and that the merged program_state preserves the sm-state.  */
 
 static void
-test_program_state2_merging ()
+test_program_state_merging ()
 {
 #if 0
   /* Create a program_state for a global ptr "p" that has
@@ -1872,7 +1508,7 @@ test_program_state2_merging ()
       = model0->get_or_create_ptr_svalue (ptr_type_node, new_rid);
   model0->set_value (model0->get_lvalue (p, &ctxt),
 		     ptr_sid, &ctxt);
-  sm_state_map2 *smap = s0.m_checker_states[0];
+  sm_state_map *smap = s0.m_checker_states[0];
   const state_machine::state_t TEST_STATE = 3;
   smap->impl_set_state (ptr_sid, TEST_STATE, svalue_id::null ());
   ASSERT_EQ (smap->get_state (ptr_sid), TEST_STATE);
@@ -1895,7 +1531,7 @@ test_program_state2_merging ()
 
   /* Verify that the merged state has the sm-state for "p".  */
   region_model *merged_model = merged.m_region_model;
-  sm_state_map2 *merged_smap = merged.m_checker_states[0];
+  sm_state_map *merged_smap = merged.m_checker_states[0];
   ASSERT_EQ (merged_smap->get_state (merged_model->get_rvalue (p, NULL)),
 	     TEST_STATE);
 
@@ -1917,7 +1553,7 @@ test_program_state2_merging ()
    can't be merged.  */
 
 static void
-test_program_state2_merging_2 ()
+test_program_state_merging_2 ()
 {
 #if 0
   auto_delete_vec <state_machine> checkers;
@@ -1926,7 +1562,7 @@ test_program_state2_merging_2 ()
 
   program_state s0 (ext_state);
   {
-    sm_state_map2 *smap0 = s0.m_checker_states[0];
+    sm_state_map *smap0 = s0.m_checker_states[0];
     const state_machine::state_t TEST_STATE_0 = 0;
     smap0->set_global_state (TEST_STATE_0);
     ASSERT_EQ (smap0->get_global_state (), TEST_STATE_0);
@@ -1934,7 +1570,7 @@ test_program_state2_merging_2 ()
 
   program_state s1 (ext_state);
   {
-    sm_state_map2 *smap1 = s1.m_checker_states[0];
+    sm_state_map *smap1 = s1.m_checker_states[0];
     const state_machine::state_t TEST_STATE_1 = 1;
     smap1->set_global_state (TEST_STATE_1);
     ASSERT_EQ (smap1->get_global_state (), TEST_STATE_1);
@@ -1958,12 +1594,6 @@ analyzer_program_state_cc_tests ()
   test_program_state_dumping_2 ();
   test_program_state_merging ();
   test_program_state_merging_2 ();
-
-  test_sm_state_map2 ();
-  test_program_state2_dumping ();
-  test_program_state2_dumping_2 ();
-  test_program_state2_merging ();
-  test_program_state2_merging_2 ();
 }
 
 } // namespace selftest
diff --git a/gcc/analyzer/program-state.h b/gcc/analyzer/program-state.h
index 22b7a6bf297..6c3a7bf5af7 100644
--- a/gcc/analyzer/program-state.h
+++ b/gcc/analyzer/program-state.h
@@ -30,8 +30,8 @@ class extrinsic_state
 public:
   extrinsic_state (auto_delete_vec <state_machine> &checkers,
 		   logger *logger = NULL,
-		   engine2 *eng2 = NULL)
-  : m_checkers (checkers), m_logger (logger), m_engine2 (eng2)
+		   engine *eng = NULL)
+  : m_checkers (checkers), m_logger (logger), m_engine (eng)
   {
   }
 
@@ -53,21 +53,21 @@ public:
   void dump_to_file (FILE *outf) const;
   void dump () const;
 
-  engine2 *get_engine2 () const { return m_engine2; }
-  region_model2_manager *get_model_manager () const;
+  engine *get_engine () const { return m_engine; }
+  region_model_manager *get_model_manager () const;
 
 private:
   /* The state machines.  */
   auto_delete_vec <state_machine> &m_checkers;
 
   logger *m_logger;
-  engine2 *m_engine2;
+  engine *m_engine;
 };
 
-/* Map from svalue2 * to state machine state, also capturing the origin of
+/* Map from svalue * to state machine state, also capturing the origin of
    each state.  */
 
-class sm_state_map2
+class sm_state_map
 {
 public:
   /* An entry in the hash_map.  */
@@ -80,7 +80,7 @@ public:
     }
 
     entry_t (state_machine::state_t state,
-	     const svalue2 *origin)
+	     const svalue *origin)
     : m_state (state), m_origin (origin)
     {}
 
@@ -95,16 +95,16 @@ public:
     }
 
     state_machine::state_t m_state;
-    const svalue2 *m_origin;
+    const svalue *m_origin;
   };
-  typedef hash_map <const svalue2 *, entry_t> map_t;
+  typedef hash_map <const svalue *, entry_t> map_t;
   typedef map_t::iterator iterator_t;
 
-  sm_state_map2 (const state_machine &sm, int m_sm_idx);
+  sm_state_map (const state_machine &sm, int m_sm_idx);
 
-  sm_state_map2 *clone () const;
+  sm_state_map *clone () const;
 
-  void print (const region_model2 *model,
+  void print (const region_model *model,
 	      bool simple, bool multiline,
 	      pretty_printer *pp) const;
   void dump (bool simple) const;
@@ -113,29 +113,29 @@ public:
 
   hashval_t hash () const;
 
-  bool operator== (const sm_state_map2 &other) const;
-  bool operator!= (const sm_state_map2 &other) const
+  bool operator== (const sm_state_map &other) const;
+  bool operator!= (const sm_state_map &other) const
   {
     return !(*this == other);
   }
 
-  state_machine::state_t get_state (const svalue2 *sval,
+  state_machine::state_t get_state (const svalue *sval,
 				    const extrinsic_state &ext_state) const;
-  const svalue2 *get_origin (const svalue2 *sval,
+  const svalue *get_origin (const svalue *sval,
 			     const extrinsic_state &ext_state) const;
 
-  void set_state (region_model2 *model,
-		  const svalue2 *sval,
+  void set_state (region_model *model,
+		  const svalue *sval,
 		  state_machine::state_t state,
-		  const svalue2 *origin,
+		  const svalue *origin,
 		  const extrinsic_state &ext_state);
-  bool set_state (const equiv_class2 &ec,
+  bool set_state (const equiv_class &ec,
 		  state_machine::state_t state,
-		  const svalue2 *origin,
+		  const svalue *origin,
 		  const extrinsic_state &ext_state);
-  bool impl_set_state (const svalue2 *sval,
+  bool impl_set_state (const svalue *sval,
 		       state_machine::state_t state,
-		       const svalue2 *origin,
+		       const svalue *origin,
 		       const extrinsic_state &ext_state);
 
   void set_global_state (state_machine::state_t state);
@@ -143,25 +143,17 @@ public:
 
   void purge_for_unknown_fncall (const exploded_graph &eg,
 				 const gcall *call, tree fndecl,
-				 region_model2 *new_model,
-				 region_model2_context *ctxt);
+				 region_model *new_model,
+				 region_model_context *ctxt);
 
-  void on_svalue2_leak (const svalue2 *sval,
-			impl_region_model2_context *ctxt);
-  void on_liveness_change (const hash_set<const svalue2 *> &live_svalues,
-			   const region_model2 *model,
-			   impl_region_model2_context *ctxt);
-
-#if 0
-  void on_inherited_svalue (svalue_id parent_sid,
-			    svalue_id child_sid);
-
-  void on_cast (svalue_id src_sid,
-		svalue_id dst_sid);
-#endif
+  void on_svalue_leak (const svalue *sval,
+			impl_region_model_context *ctxt);
+  void on_liveness_change (const hash_set<const svalue *> &live_svalues,
+			   const region_model *model,
+			   impl_region_model_context *ctxt);
 
   void on_unknown_change (const state_machine &sm,
-			  const svalue2 *sval,
+			  const svalue *sval,
 			  bool is_mutable,
 			  const extrinsic_state &ext_state);
 
@@ -171,8 +163,8 @@ public:
   iterator_t begin () const { return m_map.begin (); }
   iterator_t end () const { return m_map.end (); }
 
-  static const svalue2 *
-  canonicalize_svalue2 (const svalue2 *sval, const extrinsic_state &ext_state);
+  static const svalue *
+  canonicalize_svalue (const svalue *sval, const extrinsic_state &ext_state);
 
 private:
   const state_machine &m_sm;
@@ -236,16 +228,16 @@ public:
 				 const program_point &point,
 				 const exploded_node *enode_for_diag) const;
 
-  tree get_representative_tree2 (const svalue2 *sval) const;
+  tree get_representative_tree (const svalue *sval) const;
 
-  bool can_purge_p2 (const extrinsic_state &ext_state,
-		     const svalue2 *sval)
+  bool can_purge_p (const extrinsic_state &ext_state,
+		     const svalue *sval)
   {
     /* Don't purge vars that have non-purgeable sm state, to avoid
        generating false "leak" complaints.  */
     int i;
-    sm_state_map2 *smap;
-    FOR_EACH_VEC_ELT (m_checker_states2, i, smap)
+    sm_state_map *smap;
+    FOR_EACH_VEC_ELT (m_checker_states, i, smap)
       {
 	const state_machine &sm = ext_state.get_sm (i);
 	if (!sm.can_purge_p (smap->get_state (sval, ext_state)))
@@ -255,25 +247,21 @@ public:
   }
 
   bool can_merge_with_p (const program_state &other,
-			 const extrinsic_state &ext_state,
-			 const program_point &point,
-			 program_state *out) const;
-  bool can_merge_with2_p (const program_state &other,
 			  const extrinsic_state &ext_state,
 			  const program_point &point,
 			  program_state *out) const;
 
   void validate (const extrinsic_state &ext_state) const;
 
-  static void detect_leaks2 (const program_state &src_state,
-			     const program_state &dest_state,
-			     const svalue2 *extra_sval,
-			     const extrinsic_state &ext_state,
-			     region_model2_context *ctxt);
+  static void detect_leaks (const program_state &src_state,
+			    const program_state &dest_state,
+			    const svalue *extra_sval,
+			    const extrinsic_state &ext_state,
+			    region_model_context *ctxt);
 
   /* TODO: lose the pointer here (const-correctness issues?).  */
-  region_model2 *m_region_model2;
-  auto_delete_vec<sm_state_map2> m_checker_states2;
+  region_model *m_region_model;
+  auto_delete_vec<sm_state_map> m_checker_states;
 
   /* If false, then don't attempt to explore further states along this path.
      For use in "handling" lvalues for tree codes we haven't yet
@@ -281,12 +269,12 @@ public:
   bool m_valid;
 };
 
-/* An abstract base class for use with for_each_state_change2.  */
+/* An abstract base class for use with for_each_state_change.  */
 
-class state_change_visitor2
+class state_change_visitor
 {
 public:
-  virtual ~state_change_visitor2 () {}
+  virtual ~state_change_visitor () {}
 
   /* Return true for early exit, false to keep iterating.  */
   virtual bool on_global_state_change (const state_machine &sm,
@@ -297,14 +285,14 @@ public:
   virtual bool on_state_change (const state_machine &sm,
 				state_machine::state_t src_sm_val,
 				state_machine::state_t dst_sm_val,
-				const svalue2 *dst_sval,
-				const svalue2 *dst_origin_sval) = 0;
+				const svalue *dst_sval,
+				const svalue *dst_origin_sval) = 0;
 };
 
-extern bool for_each_state_change2 (const program_state &src_state,
+extern bool for_each_state_change (const program_state &src_state,
 				    const program_state &dst_state,
 				    const extrinsic_state &ext_state,
-				    state_change_visitor2 *visitor);
+				    state_change_visitor *visitor);
 
 /* A class for recording "interesting" state changes.
    This is used for annotating edges in the GraphViz output of the
@@ -333,9 +321,6 @@ class state_change
 
     void dump (pretty_printer *pp, const extrinsic_state &ext_state) const;
 
-    void remap_svalue_ids (const svalue_id_map &map);
-    int on_svalue_purge (svalue_id first_unused_sid);
-
     void validate (const program_state &new_state,
 		   const extrinsic_state &ext_state) const;
 
@@ -358,9 +343,6 @@ class state_change
   void dump (pretty_printer *pp, const extrinsic_state &ext_state) const;
   void dump (const extrinsic_state &ext_state) const;
 
-  void remap_svalue_ids (const svalue_id_map &map);
-  int on_svalue_purge (svalue_id first_unused_sid);
-
   void validate (const program_state &new_state,
 		 const extrinsic_state &ext_state) const;
 
diff --git a/gcc/analyzer/region-model.cc b/gcc/analyzer/region-model.cc
index 890f7006fee..292d268300d 100644
--- a/gcc/analyzer/region-model.cc
+++ b/gcc/analyzer/region-model.cc
@@ -119,60 +119,12 @@ dump_separator (pretty_printer *pp, bool *is_first)
   *is_first = false;
 }
 
-#if 0
-/* Concrete subclass of constraint_manager that wires it up to a region_model2
-   (whilst allowing the constraint_manager and region_model2 to be somewhat
-   at arms length).
-   TODO: revisit this; maybe put the region_model2 * into the constraint_manager
-   base class.  */
-
-class impl_constraint_manager : public constraint_manager
-{
- public:
-  impl_constraint_manager (region_model2 *model)
-  : constraint_manager (),
-    m_model (model)
-  {}
-
-  impl_constraint_manager (const impl_constraint_manager &other,
-			   region_model2 *model)
-  : constraint_manager (other),
-    m_model (model)
-  {}
-
-  constraint_manager *clone (region_model2 *model) const
-  {
-    return new impl_constraint_manager (*this, model);
-  }
-
-  tree maybe_get_constant (const svalue2 *sval) const FINAL OVERRIDE
-  {
-    const svalue2 *svalue2 = m_model->get_svalue2 (sid);
-    return svalue2->maybe_get_constant ();
-  }
-
-  svalue2_id get_sid_for_constant (tree cst) const FINAL OVERRIDE
-  {
-    gcc_assert (CONSTANT_CLASS_P (cst));
-    return m_model->get_rvalue (cst, NULL);
-  }
-
-  int get_num_svalue2s () const FINAL OVERRIDE
-  {
-    return m_model->get_num_svalue2s ();
-  }
-
- private:
-  region_model2 *m_model;
-};
-#endif
-
 /* struct complexity.  */
 
 /* Get complexity for a new node that references REG
    (the complexity of REG, plus one for the new node).  */
 
-complexity::complexity (const region2 *reg)
+complexity::complexity (const region *reg)
 : m_num_nodes (reg->get_complexity ().m_num_nodes + 1),
   m_max_depth (reg->get_complexity ().m_max_depth + 1)
 {
@@ -181,7 +133,7 @@ complexity::complexity (const region2 *reg)
 /* Get complexity for a new node that references SVAL.
    (the complexity of SVAL, plus one for the new node).  */
 
-complexity::complexity (const svalue2 *sval)
+complexity::complexity (const svalue *sval)
 : m_num_nodes (sval->get_complexity ().m_num_nodes + 1),
   m_max_depth (sval->get_complexity ().m_max_depth + 1)
 {
@@ -197,33 +149,14 @@ complexity::from_pair (const complexity &c1, const complexity &c2)
 		     MAX (c1.m_max_depth, c2.m_max_depth) + 1);
 }
 
-/* class svalue2 and its various subclasses.  */
-
-/* class svalue2.  */
+/* class svalue and its various subclasses.  */
 
-/* Dump this svalue2 in the form of a .dot record to PP.  */
-
-#if 0
-void
-svalue2::dump_dot_to_pp (const region_model2 &model,
-			pretty_printer *pp) const
-{
-  this_sval.dump_node_name_to_pp (pp);
-  pp_printf (pp, " [label=\"");
-  pp_write_text_to_stream (pp);
-  this_sval.print (pp);
-  pp_string (pp, ": {");
-  print (model, this_sval, pp);
-  pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/false);
-  pp_string (pp, "}\"];");
-  pp_newline (pp);
-}
-#endif
+/* class svalue.  */
 
 /* FIXME.  */
 
 DEBUG_FUNCTION void
-svalue2::dump (bool simple) const
+svalue::dump (bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -237,7 +170,7 @@ svalue2::dump (bool simple) const
 /* FIXME.  */
 
 label_text
-svalue2::get_desc (bool simple) const
+svalue::get_desc (bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -245,46 +178,46 @@ svalue2::get_desc (bool simple) const
   return label_text::take (xstrdup (pp_formatted_text (&pp)));
 }
 
-/* If this svalue2 is a constant_svalue2, return the underlying tree constant.
+/* If this svalue is a constant_svalue, return the underlying tree constant.
    Otherwise return NULL_TREE.  */
 
 tree
-svalue2::maybe_get_constant () const
+svalue::maybe_get_constant () const
 {
-  if (const constant_svalue2 *cst_sval = dyn_cast_constant_svalue2 ())
+  if (const constant_svalue *cst_sval = dyn_cast_constant_svalue ())
     return cst_sval->get_constant ();
   else
     return NULL_TREE;
 }
 
-/* If this svalue2 is a cast (i.e a unaryop NOP_EXPR), return the underlying
-   svalue2.
+/* If this svalue is a cast (i.e a unaryop NOP_EXPR), return the underlying
+   svalue.
    Otherwise return NULL.  */
 
-const svalue2 *
-svalue2::maybe_undo_cast () const
+const svalue *
+svalue::maybe_undo_cast () const
 {
-  if (const unaryop_svalue2 *unaryop_sval = dyn_cast_unaryop_svalue2 ())
+  if (const unaryop_svalue *unaryop_sval = dyn_cast_unaryop_svalue ())
     if (unaryop_sval->get_op () == NOP_EXPR)
       return unaryop_sval->get_arg ();
   return NULL;
 }
 
-const svalue2 *
-svalue2::unwrap_any_unmergeable () const
+const svalue *
+svalue::unwrap_any_unmergeable () const
 {
-  if (const unmergeable_svalue2 *unmergeable = dyn_cast_unmergeable_svalue2 ())
+  if (const unmergeable_svalue *unmergeable = dyn_cast_unmergeable_svalue ())
     return unmergeable->get_arg ();
   return this;
 }
 
-/* Attempt to merge THIS with OTHER, returning the merged svalue2.
+/* Attempt to merge THIS with OTHER, returning the merged svalue.
    Return NULL if not mergeable.  */
 
-const svalue2 *
-svalue2::can_merge_p (const svalue2 *other,
-		      region_model2_manager *mgr,
-		      model2_merger *merger) const
+const svalue *
+svalue::can_merge_p (const svalue *other,
+		     region_model_manager *mgr,
+		     model_merger *merger) const
 {
   if (!(get_type () && other->get_type ()))
     return NULL;
@@ -294,8 +227,8 @@ svalue2::can_merge_p (const svalue2 *other,
     return NULL;
 
   /* Reject attempts to merge unmergeable svalues.  */
-  if ((get_kind () == svalue2::SK_UNMERGEABLE)
-      || (other->get_kind () == svalue2::SK_UNMERGEABLE))
+  if ((get_kind () == svalue::SK_UNMERGEABLE)
+      || (other->get_kind () == svalue::SK_UNMERGEABLE))
     return NULL;
 
   /* Reject attempts to merge NULL pointers with not-NULL-pointers.  */
@@ -319,7 +252,7 @@ svalue2::can_merge_p (const svalue2 *other,
   if (tree cst0 = maybe_get_constant ())
     if (tree cst1 = other->maybe_get_constant ())
       {
-	return mgr->get_or_create_widening_svalue2 (other->get_type (),
+	return mgr->get_or_create_widening_svalue (other->get_type (),
 						    merger->m_point,
 						    other, this);
       }
@@ -328,18 +261,18 @@ svalue2::can_merge_p (const svalue2 *other,
 
   /* Merge: (Widen(existing_val, V), existing_val) -> Widen (existing_val, V)
      and thus get a fixed point.  */
-  if (const widening_svalue2 *widen_sval = dyn_cast_widening_svalue2 ())
+  if (const widening_svalue *widen_sval = dyn_cast_widening_svalue ())
     {
       /* FIXME: which direction??? */
-      if (other == widen_sval->get_base_svalue2 ())
+      if (other == widen_sval->get_base_svalue ())
 	return this;
-      if (other == widen_sval->get_iter_svalue2 ())
+      if (other == widen_sval->get_iter_svalue ())
 	return this;
     }
 
-  if (const binop_svalue2 *binop_sval = dyn_cast_binop_svalue2 ())
-    if (const widening_svalue2 *widen_arg0
-	= binop_sval->get_arg0 ()->dyn_cast_widening_svalue2 ())
+  if (const binop_svalue *binop_sval = dyn_cast_binop_svalue ())
+    if (const widening_svalue *widen_arg0
+	= binop_sval->get_arg0 ()->dyn_cast_widening_svalue ())
       {
 	if (other == binop_sval->get_arg1 ())
 	  {
@@ -368,17 +301,17 @@ svalue2::can_merge_p (const svalue2 *other,
       }
 #endif
 
-  return mgr->get_or_create_unknown_svalue2 (get_type ());
+  return mgr->get_or_create_unknown_svalue (get_type ());
 }
 
 /* FIXME.  */
 
 bool
-svalue2::live_p (const hash_set<const svalue2 *> &live_svalues,
-		 const region_model2 *model) const
+svalue::live_p (const hash_set<const svalue *> &live_svalues,
+		 const region_model *model) const
 {
   /* Determine if SVAL is explicitly live.  */
-  if (const_cast<hash_set<const svalue2 *> &> (live_svalues).contains (this))
+  if (const_cast<hash_set<const svalue *> &> (live_svalues).contains (this))
     return true;
 
   /* Otherwise, determine if SVAL is implicitly live due to being made of
@@ -386,10 +319,10 @@ svalue2::live_p (const hash_set<const svalue2 *> &live_svalues,
   return implicitly_live_p (live_svalues, model);
 }
 
-/* Base implementation of svalue2::implicitly_live_p.  */
+/* Base implementation of svalue::implicitly_live_p.  */
 
 bool
-svalue2::implicitly_live_p (const svalue2_set &, const region_model2 *) const
+svalue::implicitly_live_p (const svalue_set &, const region_model *) const
 {
   return false;
 }
@@ -399,17 +332,17 @@ svalue2::implicitly_live_p (const svalue2_set &, const region_model2 *) const
 /* Constants are implicitly live.  */
 
 bool
-constant_svalue2::implicitly_live_p (const svalue2_set &,
-				     const region_model2 *) const
+constant_svalue::implicitly_live_p (const svalue_set &,
+				     const region_model *) const
 {
   return true;
 }
 
 bool
-initial_svalue2::implicitly_live_p (const svalue2_set &live_svalues,
-				    const region_model2 *model) const
+initial_svalue::implicitly_live_p (const svalue_set &live_svalues,
+				    const region_model *model) const
 {
-  /* This svalue2 may be implicitly live if the region still implicitly
+  /* This svalue may be implicitly live if the region still implicitly
      has its initial value and is reachable.  */
 
   /* It must be a region that exists; we don't want to consider
@@ -417,7 +350,7 @@ initial_svalue2::implicitly_live_p (const svalue2_set &live_svalues,
      a popped stack frame.  */
   if (model->region_exists_p (m_reg))
     {
-      const svalue2 *reg_sval = model->get_store_value (m_reg);
+      const svalue *reg_sval = model->get_store_value (m_reg);
       if (reg_sval == this)
 	return true;
     }
@@ -426,40 +359,40 @@ initial_svalue2::implicitly_live_p (const svalue2_set &live_svalues,
 }
 
 bool
-unaryop_svalue2::implicitly_live_p (const svalue2_set &live_svalues,
-				    const region_model2 *model) const
+unaryop_svalue::implicitly_live_p (const svalue_set &live_svalues,
+				    const region_model *model) const
 {
   return get_arg ()->live_p (live_svalues, model);
 }
 
 bool
-binop_svalue2::implicitly_live_p (const svalue2_set &live_svalues,
-				  const region_model2 *model) const
+binop_svalue::implicitly_live_p (const svalue_set &live_svalues,
+				  const region_model *model) const
 {
   return (get_arg0 ()->live_p (live_svalues, model)
 	  && get_arg1 ()->live_p (live_svalues, model));
 }
 
 bool
-sub_svalue2::implicitly_live_p (const svalue2_set &live_svalues,
-				const region_model2 *model) const
+sub_svalue::implicitly_live_p (const svalue_set &live_svalues,
+				const region_model *model) const
 {
   return get_parent ()->live_p (live_svalues, model);
 }
 
 bool
-unmergeable_svalue2::implicitly_live_p (const svalue2_set &live_svalues,
-					const region_model2 *model) const
+unmergeable_svalue::implicitly_live_p (const svalue_set &live_svalues,
+					const region_model *model) const
 {
   return get_arg ()->live_p (live_svalues, model);
 }
 
-/* class region_svalue2 : public svalue2.  */
+/* class region_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-region_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+region_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -468,7 +401,7 @@ region_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "region_svalue2(");
+      pp_string (pp, "region_svalue(");
       print_quoted_type (pp, get_type ());
       pp_string (pp, ", ");
       m_reg->dump_to_pp (pp, simple);
@@ -476,12 +409,12 @@ region_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
 }
 
-/* Compare the fields of this region_svalue2 with OTHER, returning true
+/* Compare the fields of this region_svalue with OTHER, returning true
    if they are equal.
-   For use by svalue2::operator==.  */
+   For use by svalue::operator==.  */
 #if 0
 bool
-region_svalue2::compare_fields (const region_svalue2 &other) const
+region_svalue::compare_fields (const region_svalue &other) const
 {
   return m_reg == other.m_reg;
 }
@@ -490,143 +423,27 @@ region_svalue2::compare_fields (const region_svalue2 &other) const
 /* FIXME.  */
 
 void
-region_svalue2::accept (visitor *v) const
+region_svalue::accept (visitor *v) const
 {
-  v->visit_region_svalue2 (this);
+  v->visit_region_svalue (this);
   m_reg->accept (v);
 }
 
-/* Implementation of svalue2::dump_dot_to_pp for region_svalue2.  */
-
-#if 0
-void
-region_svalue2::dump_dot_to_pp (const region_model2 &model,
-			       svalue2_id this_sval,
-			       pretty_printer *pp) const
-{
-  svalue2::dump_dot_to_pp (model, this_sval, pp);
-
-  /* If non-NULL, add an edge to the pointed-to region2.  */
-  if (!m_reg.null_p ())
-    {
-      this_sval.dump_node_name_to_pp (pp);
-      pp_string (pp, " -> ");
-      m_reg.dump_node_name_to_pp (pp);
-      pp_string (pp, ";");
-      pp_newline (pp);
-  }
-}
-#endif
-
-#if 0
-/* Merge REGION2_SVAL_A and REGION2_SVAL_B using MERGER, writing the result
-   into *MERGED_SVAL.  */
-
-void
-region_svalue2::merge_values (const region_svalue2 &region2_sval_a,
-			     const region_svalue2 &region2_sval_b,
-			     svalue2_id *merged_sval,
-			     tree type,
-			     model_merger *merger)
-{
-  region2_id a_reg = region2_sval_a.get_pointee ();
-  region2_id b_reg = region2_sval_b.get_pointee ();
-
-  /* Both are non-NULL. */
-  gcc_assert (!a_reg.null_p () && !b_reg.null_p ());
-
-  /* Have these ptr-values already been merged?  */
-
-  region2_id a_reg_in_m
-    = merger->m_map_region2s_from_a_to_m.get_dst_for_src (a_reg);
-  region2_id b_reg_in_m
-    = merger->m_map_region2s_from_b_to_m.get_dst_for_src (b_reg);
-
-  /* "null_p" here means "we haven't seen this ptr-value before".
-     If we've seen one but not the other, or we have different
-     region2s, then the merged ptr has to be "unknown".  */
-  if (a_reg_in_m != b_reg_in_m)
-    {
-      const svalue2 *merged_sval = new unknown_svalue2 (type);
-      *merged_sval = merger->m_merged_model->add_svalue2 (merged_sval);
-      return;
-    }
-
-  /* Have we seen this yet?  If so, reuse the value.  */
-  if (!a_reg_in_m.null_p ())
-    {
-      *merged_sval
-	= merger->m_merged_model->get_or_create_ptr_svalue2 (type, a_reg_in_m);
-      return;
-    }
-
-  /* Otherwise we have A/B region2s that haven't been referenced yet.  */
-
-  /* Are the region2s the "same", when seen from the tree point-of-view.
-     If so, create a merged pointer to it.  */
-  path_var pv_a = merger->m_model_a->get_representative_path_var (a_reg);
-  path_var pv_b = merger->m_model_b->get_representative_path_var (b_reg);
-  if (pv_a.m_tree
-      && pv_a == pv_b)
-    {
-      region2_id merged_pointee_reg
-	= merger->m_merged_model->get_lvalue (pv_a, NULL);
-      *merged_sval
-	= merger->m_merged_model->get_or_create_ptr_svalue2 (type,
-							    merged_pointee_reg);
-      merger->record_region2s (a_reg, b_reg, merged_pointee_reg);
-      return;
-    }
-
-  /* Handle an A/B pair of ptrs that both point at heap region2s.
-     If they both have a heap region2 in the merger model, merge them.  */
-  region2 *region2_a = merger->m_model_a->get_region2 (a_reg);
-  region2 *region2_b = merger->m_model_b->get_region2 (b_reg);
-  region2_id a_parent_reg = region2_a->get_parent ();
-  region2_id b_parent_reg = region2_b->get_parent ();
-  region2 *parent_region2_a = merger->m_model_a->get_region2 (a_parent_reg);
-  region2 *parent_region2_b = merger->m_model_b->get_region2 (b_parent_reg);
-  if (parent_region2_a
-      && parent_region2_b
-      && parent_region2_a->get_kind () == RK_HEAP
-      && parent_region2_b->get_kind () == RK_HEAP)
-    {
-	/* We have an A/B pair of ptrs that both point at heap region2s.  */
-	/* presumably we want to see if each A/B heap region2 already
-	   has a merged region2, and, if so, is it the same one.  */
-	// This check is above
-
-	region2_id merged_pointee_reg
-	  = merger->m_merged_model->add_new_malloc_region2 ();
-	*merged_sval
-	  = merger->m_merged_model->get_or_create_ptr_svalue2
-	     (type, merged_pointee_reg);
-	merger->record_region2s (a_reg, b_reg, merged_pointee_reg);
-	return;
-    }
-
-  /* Two different non-NULL pointers?  Merge to unknown.  */
-  const svalue2 *merged_sval = new unknown_svalue2 (type);
-  *merged_sval = merger->m_merged_model->add_svalue2 (merged_sval);
-  return;
-}
-#endif
-
 /* Evaluate the condition LHS OP RHS.
-   Subroutine of region_model2::eval_condition for when we have a pair of
+   Subroutine of region_model::eval_condition for when we have a pair of
    pointers.  */
 
 tristate
-region_svalue2::eval_condition (const region_svalue2 *lhs,
+region_svalue::eval_condition (const region_svalue *lhs,
 				enum tree_code op,
-				const region_svalue2 *rhs)
+				const region_svalue *rhs)
 {
-  /* See if they point to the same region2.  */
-  const region2 *lhs_reg = lhs->get_pointee ();
-  const region2 *rhs_reg = rhs->get_pointee ();
+  /* See if they point to the same region.  */
+  const region *lhs_reg = lhs->get_pointee ();
+  const region *rhs_reg = rhs->get_pointee ();
   bool ptr_equality = lhs_reg == rhs_reg;
   // FIXME: what about when we have unknown values?
-  /* TODO: what about child region2s where the child is the first child
+  /* TODO: what about child regions where the child is the first child
      (or descendent)?
      Presumably we should look at base regions and compare offsets
      within them.  */
@@ -665,12 +482,12 @@ region_svalue2::eval_condition (const region_svalue2 *lhs,
   return tristate::TS_UNKNOWN;
 }
 
-/* class constant_svalue2 : public svalue2.  */
+/* class constant_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-constant_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+constant_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -681,7 +498,7 @@ constant_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "constant_svalue2(");
+      pp_string (pp, "constant_svalue(");
       print_quoted_type (pp, get_type ());
       pp_string (pp, ", ");
       dump_tree (pp, m_cst_expr);
@@ -692,38 +509,38 @@ constant_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 void
-constant_svalue2::accept (visitor *v) const
+constant_svalue::accept (visitor *v) const
 {
-  v->visit_constant_svalue2 (this);
+  v->visit_constant_svalue (this);
 }
 
-/* Compare the fields of this constant_svalue2 with OTHER, returning true
+/* Compare the fields of this constant_svalue with OTHER, returning true
    if they are equal.
-   For use by svalue2::operator==.  */
+   For use by svalue::operator==.  */
 #if 0
 bool
-constant_svalue2::compare_fields (const constant_svalue2 &other) const
+constant_svalue::compare_fields (const constant_svalue &other) const
 {
   return m_cst_expr == other.m_cst_expr;
 }
 #endif
 
 /* Merge the CST_SVAL_A and CST_SVAL_B using MERGER, writing the id of
-   the resulting svalue2 into *MERGED_SVAL.  */
+   the resulting svalue into *MERGED_SVAL.  */
 #if 0
 void
-constant_svalue2::merge_values (const constant_svalue2 &cst_sval_a,
-			       const constant_svalue2 &cst_sval_b,
-			       svalue2_id *merged_sval,
+constant_svalue::merge_values (const constant_svalue &cst_sval_a,
+			       const constant_svalue &cst_sval_b,
+			       svalue_id *merged_sval,
 			       model_merger *merger)
 {
   tree cst_a = cst_sval_a.get_constant ();
   tree cst_b = cst_sval_b.get_constant ();
-  const svalue2 *merged_sval;
+  const svalue *merged_sval;
   if (cst_a == cst_b)
     {
       /* If they are the same constant, merge as that constant value.  */
-      merged_sval = new constant_svalue2 (cst_a);
+      merged_sval = new constant_svalue (cst_a);
     }
   else
     {
@@ -731,20 +548,20 @@ constant_svalue2::merge_values (const constant_svalue2 &cst_sval_a,
 	 Merge as an unknown value.
 	 TODO: impose constraints on the value?
 	 (maybe just based on A, to avoid infinite chains)  */
-      merged_sval = new unknown_svalue2 (TREE_TYPE (cst_a));
+      merged_sval = new unknown_svalue (TREE_TYPE (cst_a));
     }
-  *merged_sval = merger->m_merged_model->add_svalue2 (merged_sval);
+  *merged_sval = merger->m_merged_model->add_svalue (merged_sval);
 }
 #endif
 
 /* Evaluate the condition LHS OP RHS.
-   Subroutine of region_model2::eval_condition for when we have a pair of
+   Subroutine of region_model::eval_condition for when we have a pair of
    constants.  */
 
 tristate
-constant_svalue2::eval_condition (const constant_svalue2 *lhs,
+constant_svalue::eval_condition (const constant_svalue *lhs,
 				  enum tree_code op,
-				  const constant_svalue2 *rhs)
+				  const constant_svalue *rhs)
 {
   tree lhs_const = lhs->get_constant ();
   tree rhs_const = rhs->get_constant ();
@@ -765,13 +582,13 @@ constant_svalue2::eval_condition (const constant_svalue2 *lhs,
   return tristate::TS_UNKNOWN;
 }
 
-/* Implementation of svalue2::get_child_sval vfunc for constant_svalue2.  */
+/* Implementation of svalue::get_child_sval vfunc for constant_svalue.  */
 #if 0
-svalue2_id
-constant_svalue2::get_child_sval (region2 *parent ATTRIBUTE_UNUSED,
-				region2 *child,
-				region_model2 &model,
-				region_model2_context *ctxt ATTRIBUTE_UNUSED)
+svalue_id
+constant_svalue::get_child_sval (region *parent ATTRIBUTE_UNUSED,
+				region *child,
+				region_model &model,
+				region_model_context *ctxt ATTRIBUTE_UNUSED)
 {
   /* TODO: handle the all-zeroes case by returning an all-zeroes of the
      child type.  */
@@ -780,17 +597,17 @@ constant_svalue2::get_child_sval (region2 *parent ATTRIBUTE_UNUSED,
      constant.
 
      Handle this case by using an unknown value.  */
-  const svalue2 *unknown_sval = new unknown_svalue2 (child->get_type ());
-  return model.add_svalue2 (unknown_sval);
+  const svalue *unknown_sval = new unknown_svalue (child->get_type ());
+  return model.add_svalue (unknown_sval);
 }
 #endif
 
-/* class unknown_svalue2 : public svalue2.  */
+/* class unknown_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-unknown_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+unknown_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -801,7 +618,7 @@ unknown_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "unknown_svalue2(");
+      pp_string (pp, "unknown_svalue(");
       if (get_type ())
 	dump_tree (pp, get_type ());
       pp_character (pp, ')');
@@ -811,9 +628,9 @@ unknown_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 void
-unknown_svalue2::accept (visitor *v) const
+unknown_svalue::accept (visitor *v) const
 {
-  v->visit_unknown_svalue2 (this);
+  v->visit_unknown_svalue (this);
 }
 
 /* Get a string for KIND for use in debug dumps.  */
@@ -832,14 +649,14 @@ poison_kind_to_str (enum poison_kind kind)
     }
 }
 
-/* class poisoned_svalue2 : public svalue2.  */
+/* class poisoned_svalue : public svalue.  */
 
-/* Compare the fields of this poisoned_svalue2 with OTHER, returning true
+/* Compare the fields of this poisoned_svalue with OTHER, returning true
    if they are equal.
-   For use by svalue2::operator==.  */
+   For use by svalue::operator==.  */
 #if 0
 bool
-poisoned_svalue2::compare_fields (const poisoned_svalue2 &other) const
+poisoned_svalue::compare_fields (const poisoned_svalue &other) const
 {
   return m_kind == other.m_kind;
 }
@@ -848,31 +665,31 @@ poisoned_svalue2::compare_fields (const poisoned_svalue2 &other) const
 /* FIXME.  */
 
 void
-poisoned_svalue2::accept (visitor *v) const
+poisoned_svalue::accept (visitor *v) const
 {
-  v->visit_poisoned_svalue2 (this);
+  v->visit_poisoned_svalue (this);
 }
 
 /* FIXME.  */
 
 void
-poisoned_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+poisoned_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     pp_printf (pp, "POISONED(%s)", poison_kind_to_str (m_kind));
   else
-    pp_printf (pp, "poisoned_svalue2(%s)", poison_kind_to_str (m_kind));
+    pp_printf (pp, "poisoned_svalue(%s)", poison_kind_to_str (m_kind));
 }
 
-/* class setjmp_svalue2's implementation is in engine.cc, so that it can use
+/* class setjmp_svalue's implementation is in engine.cc, so that it can use
    the declaration of exploded_node.  */
 
-/* class initial_svalue2 : public svalue2.  */
+/* class initial_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-initial_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+initial_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -882,7 +699,7 @@ initial_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "initial_svalue2(");
+      pp_string (pp, "initial_svalue(");
       print_quoted_type (pp, get_type ());
       pp_string (pp, ", ");
       m_reg->dump_to_pp (pp, simple);
@@ -893,27 +710,27 @@ initial_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 void
-initial_svalue2::accept (visitor *v) const
+initial_svalue::accept (visitor *v) const
 {
-  v->visit_initial_svalue2 (this);
+  v->visit_initial_svalue (this);
   m_reg->accept (v);
 }
 
-/* Compare the fields of this initial_svalue2 with OTHER, returning true
+/* Compare the fields of this initial_svalue with OTHER, returning true
    if they are equal.
-   For use by svalue2::operator==.  */
+   For use by svalue::operator==.  */
 #if 0
 bool
-initial_svalue2::compare_fields (const initial_svalue2 &other) const
+initial_svalue::compare_fields (const initial_svalue &other) const
 {
   return m_reg == other.m_reg;
 }
 #endif
 
-/* class unaryop_svalue2 : public svalue2.  */
+/* class unaryop_svalue : public svalue.  */
 
 void
-unaryop_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+unaryop_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -936,7 +753,7 @@ unaryop_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "unaryop_svalue2 (");
+      pp_string (pp, "unaryop_svalue (");
       // TODO: type?
       pp_string (pp, get_tree_code_name (m_op));
       pp_string (pp, ", ");
@@ -948,18 +765,18 @@ unaryop_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 void
-unaryop_svalue2::accept (visitor *v) const
+unaryop_svalue::accept (visitor *v) const
 {
-  v->visit_unaryop_svalue2 (this);
+  v->visit_unaryop_svalue (this);
   m_arg->accept (v);
 }
 
-/* class binop_svalue2 : public svalue2.  */
+/* class binop_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-binop_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+binop_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -971,7 +788,7 @@ binop_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "binop_svalue2 (");
+      pp_string (pp, "binop_svalue (");
       // TODO: type?
       pp_string (pp, get_tree_code_name (m_op));
       pp_string (pp, ", ");
@@ -985,18 +802,18 @@ binop_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 void
-binop_svalue2::accept (visitor *v) const
+binop_svalue::accept (visitor *v) const
 {
-  v->visit_binop_svalue2 (this);
+  v->visit_binop_svalue (this);
   m_arg0->accept (v);
   m_arg1->accept (v);
 }
 
-/* class sub_svalue2 : public svalue2.  */
+/* class sub_svalue : public svalue.  */
 
-sub_svalue2::sub_svalue2 (tree type, const svalue2 *parent_svalue,
-			  const region2 *subregion)
-: svalue2 (complexity::from_pair (parent_svalue->get_complexity (),
+sub_svalue::sub_svalue (tree type, const svalue *parent_svalue,
+			  const region *subregion)
+: svalue (complexity::from_pair (parent_svalue->get_complexity (),
 				  subregion->get_complexity ()),
 	   type),
   m_parent_svalue (parent_svalue), m_subregion (subregion)
@@ -1006,15 +823,15 @@ sub_svalue2::sub_svalue2 (tree type, const svalue2 *parent_svalue,
 /* FIXME.  */
 
 void
-sub_svalue2::accept (visitor *v) const
+sub_svalue::accept (visitor *v) const
 {
-  v->visit_sub_svalue2 (this);
+  v->visit_sub_svalue (this);
   m_parent_svalue->accept (v);
   m_subregion->accept (v);
 }
 
 void
-sub_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+sub_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -1026,7 +843,7 @@ sub_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "sub_svalue2 (");
+      pp_string (pp, "sub_svalue (");
       // TODO: type?
       pp_string (pp, ", ");
       m_parent_svalue->dump_to_pp (pp, simple);
@@ -1036,20 +853,20 @@ sub_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
 }
 
-/* class widening_svalue2 : public svalue2.  */
+/* class widening_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-widening_svalue2::accept (visitor *v) const
+widening_svalue::accept (visitor *v) const
 {
-  v->visit_widening_svalue2 (this);
+  v->visit_widening_svalue (this);
   m_base_sval->accept (v);
   m_iter_sval->accept (v);
 }
 
 void
-widening_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+widening_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -1064,7 +881,7 @@ widening_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "widening_svalue2 (");
+      pp_string (pp, "widening_svalue (");
       // TODO: type?
       pp_string (pp, ", ");
       pp_character (pp, '{');
@@ -1079,8 +896,8 @@ widening_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
 
 /* FIXME.  */
 
-enum widening_svalue2::direction_t
-widening_svalue2::get_direction () const
+enum widening_svalue::direction_t
+widening_svalue::get_direction () const
 {
   tree base_cst = m_base_sval->maybe_get_constant ();
   if (base_cst == NULL_TREE)
@@ -1105,7 +922,7 @@ widening_svalue2::get_direction () const
 /* FIXME.  */
 
 tristate
-widening_svalue2::eval_condition_without_cm (enum tree_code op,
+widening_svalue::eval_condition_without_cm (enum tree_code op,
 					     tree rhs_cst) const
 {
   tree base_cst = m_base_sval->maybe_get_constant ();
@@ -1192,18 +1009,18 @@ widening_svalue2::eval_condition_without_cm (enum tree_code op,
     }
 }
 
-/* class placeholder_svalue2 : public svalue2.  */
+/* class placeholder_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-placeholder_svalue2::accept (visitor *v) const
+placeholder_svalue::accept (visitor *v) const
 {
-  v->visit_placeholder_svalue2 (this);
+  v->visit_placeholder_svalue (this);
 }
 
 void
-placeholder_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+placeholder_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -1211,24 +1028,24 @@ placeholder_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_printf (pp, "placeholder_svalue2 (%qs)", m_name);
+      pp_printf (pp, "placeholder_svalue (%qs)", m_name);
       // TODO: type?
     }
 }
 
-/* class unmergeable_svalue2 : public svalue2.  */
+/* class unmergeable_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-unmergeable_svalue2::accept (visitor *v) const
+unmergeable_svalue::accept (visitor *v) const
 {
-  v->visit_unmergeable_svalue2 (this);
+  v->visit_unmergeable_svalue (this);
   m_arg->accept (v);
 }
 
 void
-unmergeable_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+unmergeable_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -1238,20 +1055,20 @@ unmergeable_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "unmergeable_svalue2 (");
+      pp_string (pp, "unmergeable_svalue (");
       m_arg->dump_to_pp (pp, simple);
       pp_character (pp, ')');
     }
 }
 
-/* class compound_svalue2 : public svalue2.  */
+/* class compound_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-compound_svalue2::accept (visitor *v) const
+compound_svalue::accept (visitor *v) const
 {
-  v->visit_compound_svalue2 (this);
+  v->visit_compound_svalue (this);
   for (binding_map::iterator_t iter = m_map.begin ();
        iter != m_map.end (); ++iter)
     {
@@ -1261,7 +1078,7 @@ compound_svalue2::accept (visitor *v) const
 }
 
 void
-compound_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+compound_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -1271,7 +1088,7 @@ compound_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "compound_svalue2 (");
+      pp_string (pp, "compound_svalue (");
       // TODO: type?
       pp_string (pp, ", ");
       pp_character (pp, '{');
@@ -1284,7 +1101,7 @@ compound_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 complexity
-compound_svalue2::calc_complexity (const binding_map &map)
+compound_svalue::calc_complexity (const binding_map &map)
 {
   unsigned num_child_nodes = 0;
   unsigned max_child_depth = 0;
@@ -1298,19 +1115,19 @@ compound_svalue2::calc_complexity (const binding_map &map)
   return complexity (num_child_nodes + 1, max_child_depth + 1);
 }
 
-/* class conjured_svalue2 : public svalue2.  */
+/* class conjured_svalue : public svalue.  */
 
 /* FIXME.  */
 
 void
-conjured_svalue2::accept (visitor *v) const
+conjured_svalue::accept (visitor *v) const
 {
-  v->visit_conjured_svalue2 (this);
+  v->visit_conjured_svalue (this);
   m_id_reg->accept (v);
 }
 
 void
-conjured_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
+conjured_svalue::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -1322,7 +1139,7 @@ conjured_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "conjured_svalue2 (");
+      pp_string (pp, "conjured_svalue (");
       // TODO: type?
       pp_string (pp, ", ");
       pp_gimple_stmt_1 (pp, m_stmt, 0, (dump_flags_t)0);
@@ -1332,12 +1149,12 @@ conjured_svalue2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
 }
 
-/* class region2 and its various subclasses.  */
+/* class region and its various subclasses.  */
 
 /* Get a string for KIND for use in debug dumps.  */
 
 const char *
-region2::kind_to_str (enum kind kind)
+region::kind_to_str (enum kind kind)
 {
   switch (kind)
     {
@@ -1364,9 +1181,9 @@ region2::kind_to_str (enum kind kind)
     }
 }
 
-/* class region2.  */
+/* class region.  */
 
-region2::~region2 ()
+region::~region ()
 {
   delete m_cached_offset;
 }
@@ -1374,18 +1191,18 @@ region2::~region2 ()
 /* FIXME.  */
 
 int
-region2::cmp_ids (const region2 *reg1, const region2 *reg2)
+region::cmp_ids (const region *reg1, const region *reg2)
 {
   return (long)reg1->get_id () - (long)reg2->get_id ();
 }
 
-/* Equality operator for region2.
+/* Equality operator for region.
    After comparing base class fields and kind, the rest of the
    comparison is handled off to a "compare_fields" member function
    specific to the appropriate subclass.  */
 
 bool
-region2::operator== (const region2 &other) const
+region::operator== (const region &other) const
 {
   if (m_parent != other.m_parent)
     return false;
@@ -1396,126 +1213,116 @@ region2::operator== (const region2 &other) const
   enum kind other_kind = other.get_kind ();
   if (this_kind != other_kind)
     return false;
-#if 0
-  /* Compare views.  */
-  if (m_view_regs.length () != other.m_view_regs.length ())
-    return false;
-  int i;
-  region2_id *rid;
-  FOR_EACH_VEC_ELT (m_view_regs, i, rid)
-    if (! (*rid == other.m_view_regs[i]))
-      return false;
-#endif
   switch (this_kind)
     {
     default:
       gcc_unreachable ();
     case RK_FRAME:
       {
-	const frame_region2 &this_sub
-	  = (const frame_region2 &)*this;
-	const frame_region2 &other_sub
-	  = (const frame_region2 &)other;
+	const frame_region &this_sub
+	  = (const frame_region &)*this;
+	const frame_region &other_sub
+	  = (const frame_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
 #if 0
     case RK_GLOBALS:
       {
-	const globals_region2 &this_sub
-	  = (const globals_region2 &)*this;
-	const globals_region2 &other_sub
-	  = (const globals_region2 &)other;
+	const globals_region &this_sub
+	  = (const globals_region &)*this;
+	const globals_region &other_sub
+	  = (const globals_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_CODE:
       {
-	const code_region2 &this_sub
-	  = (const code_region2 &)*this;
-	const code_region2 &other_sub
-	  = (const code_region2 &)other;
+	const code_region &this_sub
+	  = (const code_region &)*this;
+	const code_region &other_sub
+	  = (const code_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_FUNCTION:
       {
-	const function_region2 &this_sub
-	  = (const function_region2 &)*this;
-	const function_region2 &other_sub
-	  = (const function_region2 &)other;
+	const function_region &this_sub
+	  = (const function_region &)*this;
+	const function_region &other_sub
+	  = (const function_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_STACK:
       {
-	const stack_region2 &this_sub
-	  = (const stack_region2 &)*this;
-	const stack_region2 &other_sub
-	  = (const stack_region2 &)other;
+	const stack_region &this_sub
+	  = (const stack_region &)*this;
+	const stack_region &other_sub
+	  = (const stack_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_ROOT:
       {
-	const root_region2 &this_sub
-	  = (const root_region2 &)*this;
-	const root_region2 &other_sub
-	  = (const root_region2 &)other;
+	const root_region &this_sub
+	  = (const root_region &)*this;
+	const root_region &other_sub
+	  = (const root_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
 #endif
     case RK_SYMBOLIC:
       {
-	const symbolic_region2 &this_sub
-	  = (const symbolic_region2 &)*this;
-	const symbolic_region2 &other_sub
-	  = (const symbolic_region2 &)other;
+	const symbolic_region &this_sub
+	  = (const symbolic_region &)*this;
+	const symbolic_region &other_sub
+	  = (const symbolic_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
 #if 0
     case RK_HEAP:
       {
-	const heap_region2 &this_sub
-	  = (const heap_region2 &)*this;
-	const heap_region2 &other_sub
-	  = (const heap_region2 &)other;
+	const heap_region &this_sub
+	  = (const heap_region &)*this;
+	const heap_region &other_sub
+	  = (const heap_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
 #endif
     case RK_DECL:
       {
-	const decl_region2 &this_sub
-	  = (const decl_region2 &)*this;
-	const decl_region2 &other_sub
-	  = (const decl_region2 &)other;
+	const decl_region &this_sub
+	  = (const decl_region &)*this;
+	const decl_region &other_sub
+	  = (const decl_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_FIELD:
       {
-	const field_region2 &this_sub
-	  = (const field_region2 &)*this;
-	const field_region2 &other_sub
-	  = (const field_region2 &)other;
+	const field_region &this_sub
+	  = (const field_region &)*this;
+	const field_region &other_sub
+	  = (const field_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_ELEMENT:
       {
-	const element_region2 &this_sub
-	  = (const element_region2 &)*this;
-	const element_region2 &other_sub
-	  = (const element_region2 &)other;
+	const element_region &this_sub
+	  = (const element_region &)*this;
+	const element_region &other_sub
+	  = (const element_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_OFFSET:
       {
-	const offset_region2 &this_sub
-	  = (const offset_region2 &)*this;
-	const offset_region2 &other_sub
-	  = (const offset_region2 &)other;
+	const offset_region &this_sub
+	  = (const offset_region &)*this;
+	const offset_region &other_sub
+	  = (const offset_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     case RK_CAST:
       {
-	const cast_region2 &this_sub
-	  = (const cast_region2 &)*this;
-	const cast_region2 &other_sub
-	  = (const cast_region2 &)other;
+	const cast_region &this_sub
+	  = (const cast_region &)*this;
+	const cast_region &other_sub
+	  = (const cast_region &)other;
 	return this_sub.compare_fields (other_sub);
       }
     }
@@ -1523,10 +1330,10 @@ region2::operator== (const region2 &other) const
 
 /* FIXME.  */
 
-const region2 *
-region2::get_base_region () const
+const region *
+region::get_base_region () const
 {
-  const region2 *iter = this;
+  const region *iter = this;
   while (iter)
     {
       switch (iter->get_kind ())
@@ -1537,7 +1344,7 @@ region2::get_base_region () const
 	  iter = iter->get_parent_region ();
 	  continue;
 	case RK_CAST:
-	  iter = iter->dyn_cast_cast_region2 ()->get_original_region ();
+	  iter = iter->dyn_cast_cast_region ()->get_original_region ();
 	  continue;
 	default:
 	  return iter;
@@ -1549,7 +1356,7 @@ region2::get_base_region () const
 /* Return true if get_base_region() == this for this region.  */
 
 bool
-region2::base_region_p () const
+region::base_region_p () const
 {
   switch (get_kind ())
     {
@@ -1569,34 +1376,34 @@ region2::base_region_p () const
 // FIXME: unit test
 
 bool
-region2::descendent_of_p (const region2 *elder) const
+region::descendent_of_p (const region *elder) const
 {
-  const region2 *iter = this;
+  const region *iter = this;
   while (iter)
     {
       if (iter == elder)
 	return true;
       if (iter->get_kind () == RK_CAST)
-	iter = iter->dyn_cast_cast_region2 ()->get_original_region ();
+	iter = iter->dyn_cast_cast_region ()->get_original_region ();
       else
 	iter = iter->get_parent_region ();
     }
   return false;
 }
 
-/* If this region is a frame_region2, or a descendent of one, return it.
+/* If this region is a frame_region, or a descendent of one, return it.
    Otherwise return NULL.  */
 
-const frame_region2 *
-region2::maybe_get_frame_region () const
+const frame_region *
+region::maybe_get_frame_region () const
 {
-  const region2 *iter = this;
+  const region *iter = this;
   while (iter)
     {
-      if (const frame_region2 *frame_reg = iter->dyn_cast_frame_region2 ())
+      if (const frame_region *frame_reg = iter->dyn_cast_frame_region ())
 	return frame_reg;
       if (iter->get_kind () == RK_CAST)
-	iter = iter->dyn_cast_cast_region2 ()->get_original_region ();
+	iter = iter->dyn_cast_cast_region ()->get_original_region ();
       else
 	iter = iter->get_parent_region ();
     }
@@ -1606,9 +1413,9 @@ region2::maybe_get_frame_region () const
 /* FIXME.  */
 
 tree
-region2::maybe_get_decl () const
+region::maybe_get_decl () const
 {
-  if (const decl_region2 *decl_reg = dyn_cast_decl_region2 ())
+  if (const decl_region *decl_reg = dyn_cast_decl_region ())
     return decl_reg->get_decl ();
   return NULL_TREE;
 }
@@ -1616,7 +1423,7 @@ region2::maybe_get_decl () const
 /* FIXME.  */
 
 region_offset
-region2::get_offset () const
+region::get_offset () const
 {
   if(!m_cached_offset)
     m_cached_offset = new region_offset (calc_offset ());
@@ -1626,7 +1433,7 @@ region2::get_offset () const
 /* FIXME.  */
 
 bool
-region2::get_byte_size (byte_size_t *out) const
+region::get_byte_size (byte_size_t *out) const
 {
   tree type = get_type ();
 
@@ -1655,7 +1462,7 @@ region2::get_byte_size (byte_size_t *out) const
 /* FIXME.  */
 
 bool
-region2::get_bit_size (bit_size_t *out) const
+region::get_bit_size (bit_size_t *out) const
 {
   byte_size_t byte_size;
   if (!get_byte_size (&byte_size))
@@ -1702,11 +1509,11 @@ get_field_at_bit_offset (tree record_type, bit_offset_t bit_offset)
    its parent?   */
 
 void
-region2::get_subregions_for_binding (region_model2_manager *mgr,
+region::get_subregions_for_binding (region_model_manager *mgr,
 				     bit_offset_t relative_bit_offset,
 				     bit_size_t size_in_bits,
 				     tree type,
-				     auto_vec <const region2 *> *out) const
+				     auto_vec <const region *> *out) const
 {
   if (get_type () == NULL_TREE)
     return;
@@ -1747,9 +1554,9 @@ region2::get_subregions_for_binding (region_model2_manager *mgr,
 	      = relative_bit_offset.to_shwi () % bits_per_element;
 	    // FIXME: type ^^^^
 #endif
-	    const region2 *subregion = mgr->get_element_region
+	    const region *subregion = mgr->get_element_region
 	      (this, element_type,
-	       mgr->get_or_create_constant_svalue2 (element_index_cst));
+	       mgr->get_or_create_constant_svalue (element_index_cst));
 	    subregion->get_subregions_for_binding (mgr, inner_bit_offset,
 						   size_in_bits, type, out);
 	  }
@@ -1766,7 +1573,7 @@ region2::get_subregions_for_binding (region_model2_manager *mgr,
 						  relative_bit_offset))
 	  {
 	    int field_bit_offset = int_bit_position (field);
-	    const region2 *subregion = mgr->get_field_region (this, field);
+	    const region *subregion = mgr->get_field_region (this, field);
 	    subregion->get_subregions_for_binding
 	      (mgr, relative_bit_offset - field_bit_offset,
 	       size_in_bits, type, out);
@@ -1778,7 +1585,7 @@ region2::get_subregions_for_binding (region_model2_manager *mgr,
 	for (tree field = TYPE_FIELDS (get_type ()); field != NULL_TREE;
 	     field = DECL_CHAIN (field))
 	  {
-	    const region2 *subregion = mgr->get_field_region (this, field);
+	    const region *subregion = mgr->get_field_region (this, field);
 	    subregion->get_subregions_for_binding (mgr,
 						   relative_bit_offset,
 						   size_in_bits,
@@ -1796,9 +1603,9 @@ region2::get_subregions_for_binding (region_model2_manager *mgr,
 /* FIXME.  */
 
 region_offset
-region2::calc_offset () const
+region::calc_offset () const
 {
-  const region2 *iter_region = this;
+  const region *iter_region = this;
   bit_offset_t accum_bit_offset = 0;
 
   while (iter_region)
@@ -1807,13 +1614,13 @@ region2::calc_offset () const
 	{
 	case RK_FIELD:
 	  {
-	    const field_region2 *field_region
-	      = (const field_region2 *)iter_region;
+	    const field_region *field_reg
+	      = (const field_region *)iter_region;
 	    iter_region = iter_region->get_parent_region ();
 
 	    /* Compare with e.g. gimple-fold.c's
 	       fold_nonarray_ctor_reference.  */
-	    tree field = field_region->get_field ();
+	    tree field = field_reg->get_field ();
 	    tree byte_offset = DECL_FIELD_OFFSET (field);
 	    tree field_offset = DECL_FIELD_BIT_OFFSET (field);
 	    /* Compute bit offset of the field.  */
@@ -1826,16 +1633,16 @@ region2::calc_offset () const
 
 	case RK_ELEMENT:
 	  {
-	    const element_region2 *element_region
-	      = (const element_region2 *)iter_region;
+	    const element_region *element_reg
+	      = (const element_region *)iter_region;
 	    iter_region = iter_region->get_parent_region ();
 
 	    if (tree idx_cst
-		  = element_region->get_index ()->maybe_get_constant ())
+		  = element_reg->get_index ()->maybe_get_constant ())
 	      {
 		gcc_assert (TREE_CODE (idx_cst) == INTEGER_CST);
 
-		tree elem_type = element_region->get_type ();
+		tree elem_type = element_reg->get_type ();
 
 		// FIXME:
 #if 0
@@ -1867,12 +1674,12 @@ region2::calc_offset () const
 
 	case RK_OFFSET:
 	  {
-	    const offset_region2 *offset_region
-	      = (const offset_region2 *)iter_region;
+	    const offset_region *offset_reg
+	      = (const offset_region *)iter_region;
 	    iter_region = iter_region->get_parent_region ();
 
 	    if (tree byte_offset_cst
-		  = offset_region->get_byte_offset ()->maybe_get_constant ())
+		  = offset_reg->get_byte_offset ()->maybe_get_constant ())
 	      {
 		gcc_assert (TREE_CODE (byte_offset_cst) == INTEGER_CST);
 		/* Use a signed value for the byte offset, to handle
@@ -1892,17 +1699,17 @@ region2::calc_offset () const
 	  {
 	    /* Get the offset of a region identified symbolically from a
 	       pointer svalue.  */
-	    const symbolic_region2 *symbolic_region
-	      = (const symbolic_region2 *)iter_region;
-	    const svalue2 *sval = symbolic_region->get_pointer ();
+	    const symbolic_region *symbolic_reg
+	      = (const symbolic_region *)iter_region;
+	    const svalue *sval = symbolic_reg->get_pointer ();
 	    switch (sval->get_kind ())
 	      {
 	      default:
 		gcc_unreachable ();
-	      case svalue2::SK_BINOP:
+	      case svalue::SK_BINOP:
 		{
-		  const binop_svalue2 *binop_sval
-		    = as_a <const binop_svalue2 *> (sval);
+		  const binop_svalue *binop_sval
+		    = as_a <const binop_svalue *> (sval);
 		  switch (binop_sval->get_op ())
 		    {
 		    default:
@@ -1912,12 +1719,12 @@ region2::calc_offset () const
 			// FIXME:
 			/* If we have a symbolic value expressing pointer arithmentic,
 			   try to convert it to a suitable region.  */
-			/* FIXME: but should it be an element_region2?  that expresses
+			/* FIXME: but should it be an element_region?  that expresses
 			   things via element indices, rather than via byte offsets.  */
 			/* Perhaps instead we should capture this as an offset relative
 			   to a base region in region_offset?  */
-			const svalue2 *ptr = binop_sval->get_arg0 ();
-			const svalue2 *offset = binop_sval->get_arg1 ();
+			const svalue *ptr = binop_sval->get_arg0 ();
+			const svalue *offset = binop_sval->get_arg1 ();
 			gcc_unreachable ();
 		      }
 		    }
@@ -1930,8 +1737,8 @@ region2::calc_offset () const
 
 	case RK_CAST:
 	  {
-	    const cast_region2 *cast_reg
-	      = as_a <const cast_region2 *> (iter_region);
+	    const cast_region *cast_reg
+	      = as_a <const cast_region *> (iter_region);
 	    iter_region = cast_reg->get_original_region ();
 	  }
 	  continue;
@@ -1943,247 +1750,32 @@ region2::calc_offset () const
   return region_offset::make_concrete (iter_region, accum_bit_offset);
 }
 
-/* Set this region2's value to RHS_SVAL (or potentially a variant of it,
-   for some kinds of casts).  */
-#if 0
-void
-region2::set_value (region_model2 &model, region2 *lhs_reg, const svalue2 *rhs_sval,
-		    region_model2_context *ctxt)
-{
-  gcc_unreachable ();
-  /* Handle some kinds of casting.  */
-  if (m_type)
-    {
-      const svalue2 *sval = model.get_svalue2 (rhs_sval);
-      if (sval->get_type ())
-	rhs_sval = model.maybe_cast (m_type, rhs_sval, ctxt);
-
-      sval = model.get_svalue2 (rhs_sval);
-      if (sval->get_type ())
-	gcc_assert (m_type == sval->get_type ());
-    }
-
-  m_sval_id = rhs_sval;
-
-  /* Update views.
-     If this is a view, it becomes its parent's active view.
-     If there was already an active views, invalidate its value; otherwise
-     if the parent itself had a value, invalidate it.
-     If it's not a view, then deactivate any view that is active on this
-     region2.  */
-  {
-    if (m_is_view)
-      become_active_view (model, this_reg);
-    else
-      {
-	deactivate_any_active_view (model);
-	gcc_assert (m_active_view_reg.null_p ());
-      }
-  }
-}
-#endif
-
-
-#if 0
-/* Make this region2 (with id THIS_REG) the "active" view of its parent.
-   Any other active view has its value set to "unknown" and descendent values
-   cleared.
-   If there wasn't an active view, then set the parent's value to unknown, and
-   clear its descendent values (apart from this view).  */
-void
-region2::become_active_view (region_model2 &model, region2_id this_reg)
-{
-  gcc_assert (m_is_view);
-
-  region2 *parent_reg = model.get_region2 (m_parent_reg);
-  gcc_assert (parent_reg);
-
-  region2_id old_active_view_reg = parent_reg->m_active_view_reg;
-
-  if (old_active_view_reg == this_reg)
-    {
-      /* Already the active view: do nothing.  */
-      return;
-    }
-
-  /* We have a change of active view.  */
-  parent_reg->m_active_view_reg = this_reg;
-
-  if (old_active_view_reg.null_p ())
-    {
-      /* No previous active view, but the parent and its other children
-	 might have values.
-	 If so, invalidate those values - but not that of the new view.  */
-      region2_id_set below_region2 (&model);
-      model.get_descendents (m_parent_reg, &below_region2, this_reg);
-      for (unsigned i = 0; i < model.get_num_region2s (); i++)
-	{
-	  region2_id rid (region2_id::from_int (i));
-	  if (below_region2.region2_p (rid))
-	    {
-	      region2 *other_reg = model.get_region2 (rid);
-	      other_reg->m_sval_id = svalue2_id::null ();
-	    }
-	}
-      region2 *parent = model.get_region2 (m_parent_reg);
-      parent->m_sval_id
-	= model.add_svalue2 (new unknown_svalue2 (parent->get_type ()));
-    }
-  else
-    {
-      /* If there was an active view, invalidate it.  */
-      region2 *old_active_view = model.get_region2 (old_active_view_reg);
-      old_active_view->deactivate_view (model, old_active_view_reg);
-    }
-}
-
-/* If this region2 (with id THIS_REG) has an active view, deactivate it,
-   clearing m_active_view_reg.  */
-
-void
-region2::deactivate_any_active_view (region_model2 &model)
-{
-  if (m_active_view_reg.null_p ())
-    return;
-  region2 *view = model.get_region2 (m_active_view_reg);
-  view->deactivate_view (model, m_active_view_reg);
-  m_active_view_reg = region2_id::null ();
-}
-
-/* Clear any values for region2s below THIS_REG.
-   Set the view's value to unknown.  */
-
-void
-region2::deactivate_view (region_model2 &model, region2_id this_view_reg)
-{
-  gcc_assert (is_view_p ());
-
-  /* Purge values from old_active_this_view_reg and all its
-     descendents.  Potentially we could use a poison value
-     for this, but let's use unknown for now.  */
-  region2_id_set below_view (&model);
-  model.get_descendents (this_view_reg, &below_view, region2_id::null ());
-
-  for (unsigned i = 0; i < model.get_num_region2s (); i++)
-    {
-      region2_id rid (region2_id::from_int (i));
-      if (below_view.region2_p (rid))
-	{
-	  region2 *other_reg = model.get_region2 (rid);
-	  other_reg->m_sval_id = svalue2_id::null ();
-	}
-    }
-
-  m_sval_id = model.add_svalue2 (new unknown_svalue2 (get_type ()));
-}
-#endif
-
-/* Get a value for this region2, either its value if it has one,
-   or, failing that, "inherit" a value from first ancestor with a
-   non-null value.
-
-   For example, when getting the value for a local variable within
-   a stack frame that doesn't have one, the frame doesn't have a value
-   either, but the stack as a whole will have an "uninitialized" poison
-   value, so inherit that.  */
-#if 0
-svalue2_id
-region2::get_value (region_model2 &model, bool non_null,
-		   region_model2_context *ctxt)
-{
-  /* If this region2 has a value, use it. */
-  if (!m_sval_id.null_p ())
-    return m_sval_id;
-
-  /* Otherwise, "inherit" value from first ancestor with a
-     non-null value. */
-
-  region2 *parent = model.get_region2 (m_parent_reg);
-  if (parent)
-    {
-      svalue2_id inherited_sval
-	= parent->get_inherited_child_sval (this, model, ctxt);
-      if (!inherited_sval.null_p ())
-	return inherited_sval;
-    }
-
-  /* If a non-null value has been requested, then generate
-     a new unknown value.  Store it, so that repeated reads from this
-     region2 will yield the same unknown value.  */
-  if (non_null)
-    {
-      svalue2_id unknown_sval = model.add_svalue2 (new unknown_svalue2 (m_type));
-      m_sval_id = unknown_sval;
-      return unknown_sval;
-    }
-
-  return svalue2_id::null ();
-}
-
-/* Get a value for CHILD, inheriting from this region2.
-
-   Recurse, so this region2 will inherit a value if it doesn't already
-   have one.  */
-
-svalue2_id
-region2::get_inherited_child_sval (region2 *child,
-				 region_model2 &model,
-				 region_model2_context *ctxt)
-{
-  if (m_sval_id.null_p ())
-    {
-      /* Recurse.  */
-      if (!m_parent_reg.null_p ())
-	{
-	  region2 *parent = model.get_region2 (m_parent_reg);
-	  m_sval_id = parent->get_inherited_child_sval (this, model, ctxt);
-	}
-    }
-
-  if (!m_sval_id.null_p ())
-    {
-      /* Clone the parent's value, so that attempts to update it
-	 (e.g giving a specific value to an inherited "uninitialized"
-	 value) touch the child, and not the parent.  */
-      const svalue2 *this_value = model.get_svalue2 (m_sval_id);
-      svalue2_id new_child_sval
-	= this_value->get_child_sval (this, child, model, ctxt);
-      if (ctxt)
-	ctxt->on_inherited_svalue2 (m_sval_id, new_child_sval);
-      child->m_sval_id = new_child_sval;
-      return new_child_sval;
-    }
-
-  return svalue2_id::null ();
-}
-#endif
-
 // FIXME:
 /* Copy from SRC_REG to DST_REG, using CTXT for any issues that occur.
-   Copy across any value for the region2, and handle structs, unions
+   Copy across any value for the region, and handle structs, unions
    and arrays recursively.  */
 
 void
-region_model2::copy_region (const region2 *dst_reg, const region2 *src_reg,
-			    region_model2_context *ctxt)
+region_model::copy_region (const region *dst_reg, const region *src_reg,
+			    region_model_context *ctxt)
 {
   gcc_assert (dst_reg);
   gcc_assert (src_reg);
   if (dst_reg == src_reg)
     return;
 
-  const svalue2 *sval = get_store_value (src_reg);
+  const svalue *sval = get_store_value (src_reg);
   set_value (dst_reg, sval, ctxt);
 
 #if 0
-  /* Copy across any value for the src region2 itself.  */
-  const svalue2 *sval = src_reg->get_value (*this, true, ctxt);
+  /* Copy across any value for the src region itself.  */
+  const svalue *sval = src_reg->get_value (*this, true, ctxt);
   set_value (dst_reg, sid, ctxt);
 
   if (dst_reg->get_kind () != src_reg->get_kind ())
     return;
 
-  /* Copy across child region2s for structs, unions, and arrays.  */
+  /* Copy across child regions for structs, unions, and arrays.  */
   // FIXME
   switch (dst_reg->get_kind ())
     {
@@ -2201,142 +1793,19 @@ region_model2::copy_region (const region2 *dst_reg, const region2 *src_reg,
 #endif
 }
 
-/* Generate a hash value for this region2.  The work is done by the
+/* Generate a hash value for this region.  The work is done by the
    add_to_hash vfunc.  */
 
 hashval_t
-region2::hash () const
+region::hash () const
 {
   inchash::hash hstate;
   add_to_hash (hstate);
   return hstate.end ();
 }
 
-/* Print a one-liner representation of this region2 to PP, assuming
-   that this region2 is within MODEL and its id is THIS_REG.  */
-#if 0
-void
-region2::print (const region_model2 &model,
-	       region2_id this_reg,
-	       pretty_printer *pp) const
-{
-  this_reg.print (pp);
-  pp_string (pp, ": {");
-
-  /* vfunc.  */
-  print_fields (model, this_reg, pp);
-
-  pp_string (pp, "}");
-}
-#endif
-
-/* Base class implementation of region2::dump_dot_to_pp vfunc.  */
-#if 0
-void
-region2::dump_dot_to_pp (const region_model2 &model,
-			region2_id this_reg,
-			pretty_printer *pp) const
-{
-  this_reg.dump_node_name_to_pp (pp);
-  pp_printf (pp, " [shape=none,margin=0,style=filled,fillcolor=%s,label=\"",
-	     "lightgrey");
-  pp_write_text_to_stream (pp);
-  print (model, this_reg, pp);
-  pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/false);
-  pp_string (pp, "\"];");
-  pp_newline (pp);
-
-  /* Add edge to svalue2.  */
-  if (!m_sval_id.null_p ())
-    {
-      this_reg.dump_node_name_to_pp (pp);
-      pp_string (pp, " -> ");
-      m_sval_id.dump_node_name_to_pp (pp);
-      pp_string (pp, ";");
-      pp_newline (pp);
-    }
-
-  /* Add edge to parent.  */
-  if (!m_parent_reg.null_p ())
-    {
-      this_reg.dump_node_name_to_pp (pp);
-      pp_string (pp, " -> ");
-      m_parent_reg.dump_node_name_to_pp (pp);
-      pp_string (pp, ";");
-      pp_newline (pp);
-    }
-}
-#endif
-
-/* Dump a tree-like ASCII-art representation of this region2 to PP.  */
-#if 0
-void
-region2::dump_to_pp (const region_model2 &model,
-		    region2_id this_reg,
-		    pretty_printer *pp,
-		    const char *prefix,
-		    bool is_last_child) const
-{
-  print (model, this_reg, pp);
-  pp_newline (pp);
-
-  const char *new_prefix;
-  if (!m_parent_reg.null_p ())
-    new_prefix = ACONCAT ((prefix, is_last_child ? "  " : "|  ", NULL));
-  else
-    new_prefix = prefix;
-
-  const char *begin_color = colorize_start (pp_show_color (pp), "note");
-  const char *end_color = colorize_stop (pp_show_color (pp));
-  char *field_prefix
-    = ACONCAT ((begin_color, new_prefix, "|:", end_color, NULL));
-
-  if (!m_sval_id.null_p ())
-    {
-      pp_printf (pp, "%s sval: ", field_prefix);
-      model.get_svalue2 (m_sval_id)->print (model, m_sval_id, pp);
-      pp_newline (pp);
-    }
-  if (m_type)
-    {
-      pp_printf (pp, "%s type: ", field_prefix);
-      print_quoted_type (pp, m_type);
-      pp_newline (pp);
-    }
-
-  /* Find the children.  */
-
-  auto_vec<region2_id> child_regs;
-  unsigned i;
-  for (unsigned i = 0; i < model.get_num_region2s (); ++i)
-    {
-      region2_id rid = region2_id::from_int (i);
-      region2 *child = model.get_region2 (rid);
-      if (child->m_parent_reg == this_reg)
-	child_regs.safe_push (rid);
-    }
-
-  /* Print the children, using dump_child_label to label them.  */
-
-  region2_id *child_reg;
-  FOR_EACH_VEC_ELT (child_regs, i, child_reg)
-    {
-      is_last_child = (i == child_regs.length () - 1);
-      if (!this_reg.null_p ())
-	{
-	  const char *tail = is_last_child ? "`-" : "|-";
-	  pp_printf (pp, "%r%s%s%R", "note", new_prefix, tail);
-	}
-      dump_child_label (model, this_reg, *child_reg, pp);
-      model.get_region2 (*child_reg)->dump_to_pp (model, *child_reg, pp,
-						 new_prefix,
-						 is_last_child);
-    }
-}
-#endif
-
 DEBUG_FUNCTION void
-region2::dump (bool simple) const
+region::dump (bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -2350,7 +1819,7 @@ region2::dump (bool simple) const
 /* FIXME.  */
 
 DEBUG_FUNCTION label_text
-region2::get_desc (bool simple) const
+region::get_desc (bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -2361,100 +1830,41 @@ region2::get_desc (bool simple) const
 /* FIXME.  */
 
 void
-region2::accept (visitor *v) const
+region::accept (visitor *v) const
 {
   v->visit_region (this);
   if (m_parent)
     m_parent->accept (v);
 }
 
-/* Base implementation of region2::validate vfunc.
-   Assert that the fields of "region2" are valid; subclasses should
-   chain up their implementation to this one.  */
-#if 0
-void
-region2::validate (const region_model2 &model) const
-{
-  m_parent_reg.validate (model);
-  m_sval_id.validate (model);
-  unsigned i;
-  region2_id *view_reg;
-  FOR_EACH_VEC_ELT (m_view_regs, i, view_reg)
-    {
-      gcc_assert (!view_reg->null_p ());
-      view_reg->validate (model);
-    }
-  m_active_view_reg.validate (model);
-}
-#endif
-
-#if 0
-/* Add a new region2 with id VIEW_REG as a view of this region2.  */
-
-void
-region2::add_view (region2_id view_reg, region_model2 *model)
-{
-  gcc_assert (!view_reg.null_p ());
-  region2 *new_view = model->get_region2 (view_reg);
-  new_view->m_is_view = true;
-  gcc_assert (!new_view->m_parent_reg.null_p ());
-  gcc_assert (new_view->m_sval_id.null_p ());
-
-  //gcc_assert (new_view->get_type () != NULL_TREE);
-  // TODO: this can sometimes be NULL, when viewing through a (void *)
-
-  // TODO: the type ought to not be present yet
-
-  m_view_regs.safe_push (view_reg);
-}
-
-/* Look for a view of type TYPE of this region2, returning its id if found,
-   or null otherwise.  */
-
-region2_id
-region2::get_view (tree type, region_model2 *model) const
-{
-  unsigned i;
-  region2_id *view_reg;
-  FOR_EACH_VEC_ELT (m_view_regs, i, view_reg)
-    {
-      region2 *view = model->get_region2 (*view_reg);
-      gcc_assert (view->m_is_view);
-      if (view->get_type () == type)
-	return *view_reg;
-    }
-  return region2_id::null ();
-}
-#endif
-
 /* Return true if this is a symbolic region for deferencing an
    unknown ptr.
    We shouldn't attempt to bind values for this region (but
    can unbind values for other regions).  */
 
 bool
-region2::symbolic_for_unknown_ptr_p () const
+region::symbolic_for_unknown_ptr_p () const
 {
-  if (const symbolic_region2 *sym_reg = dyn_cast_symbolic_region2 ())
-    if (sym_reg->get_pointer ()->get_kind () == svalue2::SK_UNKNOWN)
+  if (const symbolic_region *sym_reg = dyn_cast_symbolic_region ())
+    if (sym_reg->get_pointer ()->get_kind () == svalue::SK_UNKNOWN)
       return true;
   return false;
 }
 
-/* region2's ctor.  */
+/* region's ctor.  */
 
-region2::region2 (complexity c, unsigned id, const region2 *parent, tree type)
+region::region (complexity c, unsigned id, const region *parent, tree type)
 : m_complexity (c), m_id (id), m_parent (parent), m_type (type),
   m_cached_offset (NULL)
 {
   gcc_assert (type == NULL_TREE || TYPE_P (type));
 }
 
-/* Base implementation of region2::add_to_hash vfunc; subclasses should
+/* Base implementation of region::add_to_hash vfunc; subclasses should
    chain up to this.  */
 
 void
-region2::add_to_hash (inchash::hash &hstate) const
+region::add_to_hash (inchash::hash &hstate) const
 {
   /* We deliberatly omit the id, to avoid different IDs preventing
      consolidation.  */
@@ -2465,18 +1875,18 @@ region2::add_to_hash (inchash::hash &hstate) const
 /* FIXME.  */
 
 int
-region2::cmp_ptrs (const void *p1, const void *p2)
+region::cmp_ptrs (const void *p1, const void *p2)
 {
-  const region2 * const *reg1 = (const region2 * const *)p1;
-  const region2 * const *reg2 = (const region2 * const *)p2;
+  const region * const *reg1 = (const region * const *)p1;
+  const region * const *reg2 = (const region * const *)p2;
 
   return cmp_ids (*reg1, *reg2);
 }
 
-/* Determine if a pointer to this region2 must be non-NULL.
+/* Determine if a pointer to this region must be non-NULL.
 
-   Generally, pointers to region2s must be non-NULL, but pointers
-   to symbolic_region2s might, in fact, be NULL.
+   Generally, pointers to regions must be non-NULL, but pointers
+   to symbolic_regions might, in fact, be NULL.
 
    This allows us to simulate functions like malloc and calloc with:
    - only one "outcome" from each statement,
@@ -2486,15 +1896,15 @@ region2::cmp_ptrs (const void *p1, const void *p2)
    - to be able to zero-fill for calloc.  */
 
 bool
-region2::non_null_p (const region_model2 &model) const
+region::non_null_p (const region_model &model) const
 {
 #if 1
-  /* FIXME: malloc is now simulated via a heap_allocated_region2.
+  /* FIXME: malloc is now simulated via a heap_allocated_region.
      That said, maybe we do want the possibilty of NULL for symbolic
      regions too.  */
-  /* Are we within a symbolic_region2?  If so, it could be NULL, and we
+  /* Are we within a symbolic_region?  If so, it could be NULL, and we
      have to fall back on the constraints.  */
-  if (const symbolic_region2 *sym_reg = dyn_cast_symbolic_region2 ())
+  if (const symbolic_region *sym_reg = dyn_cast_symbolic_region ())
     {
       return false; // TODO: really?
     }
@@ -2610,9 +2020,9 @@ tree_cmp (const void *p1, const void *p2)
   return tree_cmp (t1, t2);
 }
 
-/* class frame_region2 : public space_region2.  */
+/* class frame_region : public space_region.  */
 
-frame_region2::~frame_region2 ()
+frame_region::~frame_region ()
 {
   for (map_t::iterator iter = m_locals.begin ();
        iter != m_locals.end ();
@@ -2621,32 +2031,32 @@ frame_region2::~frame_region2 ()
 }
 
 void
-frame_region2::accept (visitor *v) const
+frame_region::accept (visitor *v) const
 {
-  region2::accept (v);
+  region::accept (v);
   if (m_calling_frame)
     m_calling_frame->accept (v);
 }
 
 void
-frame_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+frame_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     pp_printf (pp, "frame: %qs@%i", function_name (m_fun), get_stack_depth ());
   else
-    pp_printf (pp, "frame_region2(%qs, index: %i, depth: %i)",
+    pp_printf (pp, "frame_region(%qs, index: %i, depth: %i)",
 	       function_name (m_fun), m_index, get_stack_depth ());
 }
 
-/* Compare the fields of this frame_region2 with OTHER, returning true
+/* Compare the fields of this frame_region with OTHER, returning true
    if they are equal.
-   For use by region2::operator==.  */
+   For use by region::operator==.  */
 
 bool
-frame_region2::compare_fields (const frame_region2 &other) const
+frame_region::compare_fields (const frame_region &other) const
 {
 #if 0
-  if (!map_region2::compare_fields (other))
+  if (!map_region::compare_fields (other))
     return false;
 #endif
   if (m_fun != other.m_fun)
@@ -2659,19 +2069,19 @@ frame_region2::compare_fields (const frame_region2 &other) const
   return true;
 }
 
-/* Implementation of region2::add_to_hash vfunc for frame_region2.  */
+/* Implementation of region::add_to_hash vfunc for frame_region.  */
 #if 0
 void
-frame_region2::add_to_hash (inchash::hash &hstate) const
+frame_region::add_to_hash (inchash::hash &hstate) const
 {
-  map_region2::add_to_hash (hstate);
+  map_region::add_to_hash (hstate);
   hstate.add_ptr (m_fun);
   hstate.add_int (m_depth);
 }
 #endif
 
-const region2 *
-frame_region2::get_region_for_local (region_model2_manager *mgr,
+const region *
+frame_region::get_region_for_local (region_model_manager *mgr,
 				     tree expr) const
 {
   // TODO: could also check that VAR_DECLs are locals
@@ -2684,29 +2094,29 @@ frame_region2::get_region_for_local (region_model2_manager *mgr,
   // TODO: when is it available?
   map_t &mutable_locals = const_cast <map_t &> (m_locals);
 
-  if (region2 **slot = mutable_locals.get (expr))
+  if (region **slot = mutable_locals.get (expr))
     return *slot;
-  decl_region2 *reg
-    = new decl_region2 (mgr->alloc_region_id (), this, expr);
+  decl_region *reg
+    = new decl_region (mgr->alloc_region_id (), this, expr);
   mutable_locals.put (expr, reg);
   return reg;
 }
 
-/* class globals_region2 : public space_region2.  */
+/* class globals_region : public space_region.  */
 
-/* Compare the fields of this globals_region2 with OTHER, returning true
+/* Compare the fields of this globals_region with OTHER, returning true
    if they are equal.
-   For use by region2::operator==.  */
+   For use by region::operator==.  */
 #if 0
 bool
-globals_region2::compare_fields (const globals_region2 &other) const
+globals_region::compare_fields (const globals_region &other) const
 {
-  return map_region2::compare_fields (other);
+  return map_region::compare_fields (other);
 }
 #endif
 
 void
-globals_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+globals_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     pp_string (pp, "::");
@@ -2714,47 +2124,47 @@ globals_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     pp_string (pp, "globals");
 }
 
-/* class code_region2 : public map_region2.  */
+/* class code_region : public map_region.  */
 
-/* Compare the fields of this code_region2 with OTHER, returning true
+/* Compare the fields of this code_region with OTHER, returning true
    if they are equal.
-   For use by region2::operator==.  */
+   For use by region::operator==.  */
 #if 0
 bool
-code_region2::compare_fields (const code_region2 &other) const
+code_region::compare_fields (const code_region &other) const
 {
-  return map_region2::compare_fields (other);
+  return map_region::compare_fields (other);
 }
 #endif
 
 /* FIXME.  */
 
 void
-code_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+code_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     pp_string (pp, "code region");
   else
-    pp_string (pp, "code_region2()");
+    pp_string (pp, "code_region()");
 }
 
-/* class function_region2 : public region2.  */
+/* class function_region : public region.  */
 
-/* Compare the fields of this function_region2 with OTHER, returning true
+/* Compare the fields of this function_region with OTHER, returning true
    if they are equal.
-   For use by region2::operator==.  */
+   For use by region::operator==.  */
 #if 0
 bool
-function_region2::compare_fields (const function_region2 &other) const
+function_region::compare_fields (const function_region &other) const
 {
-  return map_region2::compare_fields (other);
+  return map_region::compare_fields (other);
 }
 #endif
 
 /* FIXME.  */
 
 void
-function_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+function_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -2762,18 +2172,18 @@ function_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "function_region2(");
+      pp_string (pp, "function_region(");
       dump_quoted_tree (pp, m_fndecl);
       pp_string (pp, ")");
     }
 }
 
-/* class label_region2 : public region2.  */
+/* class label_region : public region.  */
 
 /* FIXME.  */
 
 void
-label_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+label_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -2781,418 +2191,124 @@ label_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "label_region2(");
+      pp_string (pp, "label_region(");
       dump_quoted_tree (pp, m_label);
       pp_string (pp, ")");
     }
 }
 
-/* class stack_region2 : public region2.  */
+/* class stack_region : public region.  */
 
 void
-stack_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+stack_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     pp_string (pp, "stack region");
   else
-    pp_string (pp, "stack_region2()");
+    pp_string (pp, "stack_region()");
 }
 
-/* Compare the fields of this stack_region2 with OTHER, returning true
+/* Compare the fields of this stack_region with OTHER, returning true
    if they are equal.
-   For use by region2::operator==.  */
+   For use by region::operator==.  */
 #if 0
 bool
-stack_region2::compare_fields (const stack_region2 &other) const
+stack_region::compare_fields (const stack_region &other) const
 {
   if (m_frame_regs.length () != other.m_frame_regs.length ())
     return false;
 
-  int i;
-  region2_id *frame_reg;
-  FOR_EACH_VEC_ELT (m_frame_regs, i, frame_reg)
-    if (m_frame_regs[i] != other.m_frame_regs[i])
-      return false;
-
-  return true;
-}
-#endif
-
-/* Implementation of region2::add_to_hash vfunc for stack_region2.  */
-#if 0
-void
-stack_region2::add_to_hash (inchash::hash &hstate) const
-{
-  region2::add_to_hash (hstate);
-
-  int i;
-  region2_id *frame_reg;
-  FOR_EACH_VEC_ELT (m_frame_regs, i, frame_reg)
-    inchash::add (*frame_reg, hstate);
-}
-#endif
-
-/* Attempt to merge STACK_REGION2_A and STACK_REGION2_B using MERGER.
-   Return true if the merger is possible, false otherwise.  */
-#if 0
-bool
-stack_region2::can_merge_p (const stack_region2 *stack_region2_a,
-			   const stack_region2 *stack_region2_b,
-			   model_merger *merger)
-{
-  if (stack_region2_a->get_num_frames ()
-      != stack_region2_b->get_num_frames ())
-    return false;
-
-  region_model2 *merged_model = merger->m_merged_model;
-
-  region2_id rid_merged_stack
-    = merged_model->get_root_region2 ()->ensure_stack_region2 (merged_model);
-
-  stack_region2 *merged_stack
-    = merged_model->get_region2 <stack_region2> (rid_merged_stack);
-
-  /* First, create all frames in the merged model, without populating them.
-     The merging code assumes that all frames in the merged model already exist,
-     so we have to do this first to handle the case in which a local in an
-     older frame points at a local in a more recent frame.  */
-    for (unsigned i = 0; i < stack_region2_a->get_num_frames (); i++)
-      {
-	region2_id rid_a = stack_region2_a->get_frame_reg (i);
-	frame_region2 *frame_a = merger->get_region2_a <frame_region2> (rid_a);
-
-	region2_id rid_b = stack_region2_b->get_frame_reg (i);
-	frame_region2 *frame_b = merger->get_region2_b <frame_region2> (rid_b);
-
-	if (frame_a->get_function () != frame_b->get_function ())
-	  return false;
-
-	frame_region2 *merged_frame = new frame_region2 (rid_merged_stack,
-						       frame_a->get_function (),
-						       frame_a->get_depth ());
-	region2_id rid_merged_frame = merged_model->add_region2 (merged_frame);
-	merged_stack->push_frame (rid_merged_frame);
-      }
-
-    /* Now populate the frames we created.  */
-    for (unsigned i = 0; i < stack_region2_a->get_num_frames (); i++)
-      {
-	region2_id rid_a = stack_region2_a->get_frame_reg (i);
-	frame_region2 *frame_a = merger->get_region2_a <frame_region2> (rid_a);
-
-	region2_id rid_b = stack_region2_b->get_frame_reg (i);
-	frame_region2 *frame_b = merger->get_region2_b <frame_region2> (rid_b);
-
-	region2_id rid_merged_frame = merged_stack->get_frame_reg (i);
-	frame_region2 *merged_frame
-	  = merged_model->get_region2 <frame_region2> (rid_merged_frame);
-	if (!map_region2::can_merge_p (frame_a, frame_b,
-				      merged_frame, rid_merged_frame,
-				      merger))
-	  return false;
-      }
-
-  return true;
-}
-#endif
-
-/* For debugging purposes: look for a grandchild region2 within one of
-   the child frame region2s, where the grandchild is for a decl named
-   IDENTIFIER (or an SSA_NAME for such a decl):
-
-     stack_region2
-     `-frame_region2
-       `-region2 for decl named IDENTIFIER
-
-   returning its value, or svalue2_id::null if none are found.  */
-#if 0
-svalue2_id
-stack_region2::get_value_by_name (tree identifier,
-				 const region_model2 &model) const
-{
-  int i;
-  region2_id *frame_reg;
-  FOR_EACH_VEC_ELT (m_frame_regs, i, frame_reg)
-    {
-      frame_region2 *frame = model.get_region2<frame_region2> (*frame_reg);
-      const svalue2 *sval = frame->get_value_by_name (identifier, model);
-      if (!sid.null_p ())
-	return sid;
-    }
-
-  return svalue2_id::null ();
-}
-#endif
-
-/* class heap_region2 : public region2.  */
-
-/* Compare the fields of this heap_region2 with OTHER, returning true
-   if they are equal.
-   For use by region2::operator==.  */
-#if 0
-bool
-heap_region2::compare_fields (const heap_region2 &) const
-{
-  /* Empty.  */
-  return true;
-}
-#endif
-
-void
-heap_region2::dump_to_pp (pretty_printer *pp, bool simple) const
-{
-  if (simple)
-    pp_string (pp, "heap region");
-  else
-    pp_string (pp, "heap_region2()");
-}
-
-/* class root_region2 : public region2.  */
-
-/* root_region2's default ctor.  */
-
-root_region2::root_region2 (unsigned id)
-: region2 (complexity (1, 1), id, NULL, NULL_TREE)
-{
-}
-
-#if 0
-/* Compare the fields of this root_region2 with OTHER, returning true
-   if they are equal.
-   For use by region2::operator==.  */
-
-bool
-root_region2::compare_fields (const root_region2 &other) const
-{
-  if (m_stack_reg != other.m_stack_reg)
-    return false;
-  if (m_globals_reg != other.m_globals_reg)
-    return false;
-  if (m_code_reg != other.m_code_reg)
-    return false;
-  if (m_heap_reg != other.m_heap_reg)
-    return false;
-  return true;
-}
-#endif
-
-void
-root_region2::dump_to_pp (pretty_printer *pp, bool simple) const
-{
-  if (simple)
-    pp_string (pp, "root region");
-  else
-    pp_string (pp, "root_region2()");
-}
-
-/* Create a new frame_region2 for a call to FUN and push it onto
-   the stack.
-
-   If ARG_SVALS is non-NULL, use it to populate the parameters
-   in the new frame.
-   Otherwise, populate them with unknown values.
-
-   Return the region2_id of the new frame.  */
-#if 0
-region2_id
-root_region2::push_frame (region_model2 *model, function *fun,
-			 vec<svalue2_id> *arg_svals,
-			 region_model2_context *ctxt)
-{
-  gcc_assert (fun);
-  /* arg_svals can be NULL.  */
-
-  ensure_stack_region2 (model);
-  stack_region2 *stack = model->get_region2 <stack_region2> (m_stack_reg);
-
-  frame_region2 *region2 = new frame_region2 (m_stack_reg, fun,
-					   stack->get_num_frames ());
-  region2_id frame_reg = model->add_region2 (region2);
-
-  // TODO: unify these cases by building a vec of unknown?
-
-  if (arg_svals)
-    {
-      /* Arguments supplied from a caller frame.  */
-
-      tree fndecl = fun->decl;
-      unsigned idx = 0;
-      for (tree iter_parm = DECL_ARGUMENTS (fndecl); iter_parm;
-	   iter_parm = DECL_CHAIN (iter_parm), ++idx)
-	{
-	  /* If there's a mismatching declaration, the call stmt might
-	     not have enough args.  Handle this case by leaving the
-	     rest of the params as uninitialized.  */
-	  if (idx >= arg_svals->length ())
-	    break;
-	  svalue2_id arg_sval = (*arg_svals)[idx];
-	  region2_id parm_reg
-	    = region2->get_or_create (model, frame_reg, iter_parm,
-				     TREE_TYPE (iter_parm), ctxt);
-	  model->set_value (parm_reg, arg_sval, ctxt);
-
-	  /* Also do it for default SSA name (sharing the same unknown
-	     value).  */
-	  tree parm_default_ssa = ssa_default_def (fun, iter_parm);
-	  if (parm_default_ssa)
-	    {
-	      region2_id defssa_reg
-		= region2->get_or_create (model, frame_reg, parm_default_ssa,
-					 TREE_TYPE (iter_parm), ctxt);
-	      model->set_value (defssa_reg, arg_sval, ctxt);
-	    }
-	}
-    }
-  else
-    {
-      /* No known arguments (a top-level call within the analysis).  */
-
-      /* Params have a defined, unknown value; they should not inherit
-	 from the poisoned uninit value.  */
-      tree fndecl = fun->decl;
-      for (tree iter_parm = DECL_ARGUMENTS (fndecl); iter_parm;
-	   iter_parm = DECL_CHAIN (iter_parm))
-	{
-	  region2_id parm_reg
-	    = region2->get_or_create (model, frame_reg, iter_parm,
-				     TREE_TYPE (iter_parm), ctxt);
-	  svalue2_id parm_sval
-	    = model->set_to_new_unknown_value (parm_reg, TREE_TYPE (iter_parm),
-					       ctxt);
-
-	  /* Also do it for default SSA name (sharing the same unknown
-	     value).  */
-	  tree parm_default_ssa = ssa_default_def (fun, iter_parm);
-	  if (parm_default_ssa)
-	    {
-	      region2_id defssa_reg
-		= region2->get_or_create (model, frame_reg, parm_default_ssa,
-					 TREE_TYPE (iter_parm), ctxt);
-	      model->get_region2 (defssa_reg)->set_value (*model, defssa_reg,
-							 parm_sval, ctxt);
-	    }
-	}
-    }
-
-  stack->push_frame (frame_reg);
+  int i;
+  region_id *frame_reg;
+  FOR_EACH_VEC_ELT (m_frame_regs, i, frame_reg)
+    if (m_frame_regs[i] != other.m_frame_regs[i])
+      return false;
+
+  return true;
+}
+#endif
 
-  return frame_reg;
+/* Implementation of region::add_to_hash vfunc for stack_region.  */
+#if 0
+void
+stack_region::add_to_hash (inchash::hash &hstate) const
+{
+  region::add_to_hash (hstate);
+
+  int i;
+  region_id *frame_reg;
+  FOR_EACH_VEC_ELT (m_frame_regs, i, frame_reg)
+    inchash::add (*frame_reg, hstate);
 }
+#endif
 
-/* Return the region2_id of the stack region2, creating it if doesn't
-   already exist.  */
+/* class heap_region : public region.  */
 
-region2_id
-root_region2::ensure_stack_region2 (region_model2 *model)
+/* Compare the fields of this heap_region with OTHER, returning true
+   if they are equal.
+   For use by region::operator==.  */
+#if 0
+bool
+heap_region::compare_fields (const heap_region &) const
 {
-  if (m_stack_reg.null_p ())
-    {
-      svalue2_id uninit_sval
-	= model->add_svalue2 (new poisoned_svalue2 (POISON_KIND_UNINIT,
-						  NULL_TREE));
-      m_stack_reg
-	= model->add_region2 (new stack_region2 (model->get_root_reg (),
-					       uninit_sval));
-    }
-  return m_stack_reg;
+  /* Empty.  */
+  return true;
+}
+#endif
+
+void
+heap_region::dump_to_pp (pretty_printer *pp, bool simple) const
+{
+  if (simple)
+    pp_string (pp, "heap region");
+  else
+    pp_string (pp, "heap_region()");
 }
 
-/* Return the region2_id of the heap region2, creating it if doesn't
-   already exist.  */
+/* class root_region : public region.  */
+
+/* root_region's default ctor.  */
 
-region2_id
-root_region2::ensure_heap_region2 (region_model2 *model)
+root_region::root_region (unsigned id)
+: region (complexity (1, 1), id, NULL, NULL_TREE)
 {
-  if (m_heap_reg.null_p ())
-    {
-      svalue2_id uninit_sval
-	= model->add_svalue2 (new poisoned_svalue2 (POISON_KIND_UNINIT,
-						  NULL_TREE));
-      m_heap_reg
-	= model->add_region2 (new heap_region2 (model->get_root_reg (),
-					      uninit_sval));
-    }
-  return m_heap_reg;
 }
 
-/* Attempt to merge ROOT_REGION2_A and ROOT_REGION2_B into
-   MERGED_ROOT_REGION2 using MERGER.
-   Return true if the merger is possible, false otherwise.  */
+#if 0
+/* Compare the fields of this root_region with OTHER, returning true
+   if they are equal.
+   For use by region::operator==.  */
 
 bool
-root_region2::can_merge_p (const root_region2 *root_region2_a,
-			  const root_region2 *root_region2_b,
-			  root_region2 *merged_root_region2,
-			  model_merger *merger)
-{
-  /* We can only merge if the stacks are sufficiently similar.  */
-  stack_region2 *stack_a = root_region2_a->get_stack_region2 (merger->m_model_a);
-  stack_region2 *stack_b = root_region2_b->get_stack_region2 (merger->m_model_b);
-  if (stack_a && stack_b)
-    {
-      /* If the two models both have a stack, attempt to merge them.  */
-      merged_root_region2->ensure_stack_region2 (merger->m_merged_model);
-      if (!stack_region2::can_merge_p (stack_a, stack_b, merger))
-	return false;
-    }
-  else if (stack_a || stack_b)
-    /* Don't attempt to merge if one model has a stack and the other
-       doesn't.  */
+root_region::compare_fields (const root_region &other) const
+{
+  if (m_stack_reg != other.m_stack_reg)
+    return false;
+  if (m_globals_reg != other.m_globals_reg)
+    return false;
+  if (m_code_reg != other.m_code_reg)
+    return false;
+  if (m_heap_reg != other.m_heap_reg)
     return false;
-
-  map_region2 *globals_a = root_region2_a->get_globals_region2 (merger->m_model_a);
-  map_region2 *globals_b = root_region2_b->get_globals_region2 (merger->m_model_b);
-  if (globals_a && globals_b)
-    {
-      /* If both models have globals region2s, attempt to merge them.  */
-      region2_id merged_globals_reg
-	= merged_root_region2->ensure_globals_region2 (merger->m_merged_model);
-      map_region2 *merged_globals
-	= merged_root_region2->get_globals_region2 (merger->m_merged_model);
-      if (!map_region2::can_merge_p (globals_a, globals_b,
-				    merged_globals, merged_globals_reg,
-				    merger))
-	return false;
-    }
-  /* otherwise, merge as "no globals".  */
-
-  map_region2 *code_a = root_region2_a->get_code_region2 (merger->m_model_a);
-  map_region2 *code_b = root_region2_b->get_code_region2 (merger->m_model_b);
-  if (code_a && code_b)
-    {
-      /* If both models have code region2s, attempt to merge them.  */
-      region2_id merged_code_reg
-	= merged_root_region2->ensure_code_region2 (merger->m_merged_model);
-      map_region2 *merged_code
-	= merged_root_region2->get_code_region2 (merger->m_merged_model);
-      if (!map_region2::can_merge_p (code_a, code_b,
-				    merged_code, merged_code_reg,
-				    merger))
-	return false;
-    }
-  /* otherwise, merge as "no code".  */
-
-  heap_region2 *heap_a = root_region2_a->get_heap_region2 (merger->m_model_a);
-  heap_region2 *heap_b = root_region2_b->get_heap_region2 (merger->m_model_b);
-  if (heap_a && heap_b)
-    {
-      /* If both have a heap, create a "merged" heap.
-	 Actually merging the heap contents happens via the region_svalue2
-	 instances, as needed, when seeing pairs of region_svalue2 instances.  */
-      merged_root_region2->ensure_heap_region2 (merger->m_merged_model);
-    }
-  /* otherwise, merge as "no heap".  */
-
   return true;
 }
 #endif
 
-/* Implementation of region2::add_to_hash vfunc for root_region2.  */
+void
+root_region::dump_to_pp (pretty_printer *pp, bool simple) const
+{
+  if (simple)
+    pp_string (pp, "root region");
+  else
+    pp_string (pp, "root_region()");
+}
+
+/* Implementation of region::add_to_hash vfunc for root_region.  */
 #if 0
 void
-root_region2::add_to_hash (inchash::hash &hstate) const
+root_region::add_to_hash (inchash::hash &hstate) const
 {
-  region2::add_to_hash (hstate);
+  region::add_to_hash (hstate);
   inchash::add (m_stack_reg, hstate);
   inchash::add (m_globals_reg, hstate);
   inchash::add (m_code_reg, hstate);
@@ -3200,38 +2316,38 @@ root_region2::add_to_hash (inchash::hash &hstate) const
 }
 #endif
 
-/* For debugging purposes: look for a descendant region2 for a local
+/* For debugging purposes: look for a descendant region for a local
    or global decl named IDENTIFIER (or an SSA_NAME for such a decl),
-   returning its value, or svalue2_id::null if none are found.  */
+   returning its value, or svalue_id::null if none are found.  */
 #if 0
-svalue2_id
-root_region2::get_value_by_name (tree identifier,
-				const region_model2 &model) const
+svalue_id
+root_region::get_value_by_name (tree identifier,
+				const region_model &model) const
 {
-  if (stack_region2 *stack = get_stack_region2 (&model))
+  if (stack_region *stack = get_stack_region (&model))
     {
-      const svalue2 *sval = stack->get_value_by_name (identifier, model);
+      const svalue *sval = stack->get_value_by_name (identifier, model);
       if (!sid.null_p ())
 	return sid;
     }
-  if (map_region2 *globals = get_globals_region2 (&model))
+  if (map_region *globals = get_globals_region (&model))
     {
-      const svalue2 *sval = globals->get_value_by_name (identifier, model);
+      const svalue *sval = globals->get_value_by_name (identifier, model);
       if (!sid.null_p ())
 	return sid;
     }
-  return svalue2_id::null ();
+  return svalue_id::null ();
 }
 #endif
 
-/* class symbolic_region2 : public map_region2.  */
+/* class symbolic_region : public map_region.  */
 
-/* Compare the fields of this symbolic_region2 with OTHER, returning true
+/* Compare the fields of this symbolic_region with OTHER, returning true
    if they are equal.
-   For use by region2::operator==.  */
+   For use by region::operator==.  */
 
 bool
-symbolic_region2::compare_fields (const symbolic_region2 &other) const
+symbolic_region::compare_fields (const symbolic_region &other) const
 {
   return m_sval_ptr == other.m_sval_ptr;
 }
@@ -3239,16 +2355,16 @@ symbolic_region2::compare_fields (const symbolic_region2 &other) const
 /* FIXME.  */
 
 void
-symbolic_region2::accept (visitor *v) const
+symbolic_region::accept (visitor *v) const
 {
-  region2::accept (v);
+  region::accept (v);
   m_sval_ptr->accept (v);
 }
 
 /* FIXME.  */
 
 void
-symbolic_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+symbolic_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -3258,7 +2374,7 @@ symbolic_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "symbolic_region2(");
+      pp_string (pp, "symbolic_region(");
       get_parent_region ()->dump_to_pp (pp, simple);
       pp_string (pp, ", ");
       print_quoted_type (pp, get_type ());
@@ -3268,29 +2384,29 @@ symbolic_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
 }
 
-/* class decl_region2 : public region2.  */
+/* class decl_region : public region.  */
 
 void
-decl_region2::add_to_hash (inchash::hash &hstate) const
+decl_region::add_to_hash (inchash::hash &hstate) const
 {
-  region2::add_to_hash (hstate);
+  region::add_to_hash (hstate);
   hstate.add_ptr (m_decl);
 }
 
 bool
-decl_region2::compare_fields (const decl_region2 &other) const
+decl_region::compare_fields (const decl_region &other) const
 {
   return m_decl == other.m_decl;
 }
 
 void
-decl_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+decl_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     pp_printf (pp, "%E", m_decl);
   else
     {
-      pp_string (pp, "decl_region2(");
+      pp_string (pp, "decl_region(");
       get_parent_region ()->dump_to_pp (pp, simple);
       pp_string (pp, ", ");
       print_quoted_type (pp, get_type ());
@@ -3301,33 +2417,33 @@ decl_region2::dump_to_pp (pretty_printer *pp, bool simple) const
 /* FIXME.  */
 
 int
-decl_region2::get_stack_depth () const
+decl_region::get_stack_depth () const
 {
   if (get_parent_region () == NULL)
     return 0;
-  if (const frame_region2 *frame_reg
-	= get_parent_region ()->dyn_cast_frame_region2 ())
+  if (const frame_region *frame_reg
+	= get_parent_region ()->dyn_cast_frame_region ())
     return frame_reg->get_stack_depth ();
   return 0;
 }
 
-/* class field_region2 : public region2.  */
+/* class field_region : public region.  */
 
 void
-field_region2::add_to_hash (inchash::hash &hstate) const
+field_region::add_to_hash (inchash::hash &hstate) const
 {
-  region2::add_to_hash (hstate);
+  region::add_to_hash (hstate);
   hstate.add_ptr (m_field);
 }
 
 bool
-field_region2::compare_fields (const field_region2 &other) const
+field_region::compare_fields (const field_region &other) const
 {
   return m_field == other.m_field;
 }
 
 void
-field_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+field_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -3337,7 +2453,7 @@ field_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "field_region2(");
+      pp_string (pp, "field_region(");
       get_parent_region ()->dump_to_pp (pp, simple);
       pp_string (pp, ", ");
       print_quoted_type (pp, get_type ());
@@ -3345,10 +2461,10 @@ field_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
 }
 
-/* class element_region2 : public region2.  */
+/* class element_region : public region.  */
 
 bool
-element_region2::compare_fields (const element_region2 &other) const
+element_region::compare_fields (const element_region &other) const
 {
   return m_index == other.m_index;
 }
@@ -3356,14 +2472,14 @@ element_region2::compare_fields (const element_region2 &other) const
 /* FIXME.  */
 
 void
-element_region2::accept (visitor *v) const
+element_region::accept (visitor *v) const
 {
-  region2::accept (v);
+  region::accept (v);
   m_index->accept (v);
 }
 
 void
-element_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+element_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -3376,7 +2492,7 @@ element_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "element_region2(");
+      pp_string (pp, "element_region(");
       get_parent_region ()->dump_to_pp (pp, simple);
       pp_string (pp, ", ");
       print_quoted_type (pp, get_type ());
@@ -3387,16 +2503,16 @@ element_region2::dump_to_pp (pretty_printer *pp, bool simple) const
 }
 
 void
-element_region2::add_to_hash (inchash::hash &hstate) const
+element_region::add_to_hash (inchash::hash &hstate) const
 {
-  region2::add_to_hash (hstate);
+  region::add_to_hash (hstate);
   hstate.add_ptr (m_index);
 }
 
-/* class offset_region2 : public region2.  */
+/* class offset_region : public region.  */
 
 bool
-offset_region2::compare_fields (const offset_region2 &other) const
+offset_region::compare_fields (const offset_region &other) const
 {
   return m_byte_offset == other.m_byte_offset;
 }
@@ -3404,14 +2520,14 @@ offset_region2::compare_fields (const offset_region2 &other) const
 /* FIXME.  */
 
 void
-offset_region2::accept (visitor *v) const
+offset_region::accept (visitor *v) const
 {
-  region2::accept (v);
+  region::accept (v);
   m_byte_offset->accept (v);
 }
 
 void
-offset_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+offset_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -3423,7 +2539,7 @@ offset_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "offset_region2(");
+      pp_string (pp, "offset_region(");
       get_parent_region ()->dump_to_pp (pp, simple);
       pp_string (pp, ", ");
       print_quoted_type (pp, get_type ());
@@ -3434,16 +2550,16 @@ offset_region2::dump_to_pp (pretty_printer *pp, bool simple) const
 }
 
 void
-offset_region2::add_to_hash (inchash::hash &hstate) const
+offset_region::add_to_hash (inchash::hash &hstate) const
 {
-  region2::add_to_hash (hstate);
+  region::add_to_hash (hstate);
   hstate.add_ptr (m_byte_offset);
 }
 
-/* class cast_region2 : public region2.  */
+/* class cast_region : public region.  */
 
 bool
-cast_region2::compare_fields (const cast_region2 &other) const
+cast_region::compare_fields (const cast_region &other) const
 {
   return m_original_region == other.m_original_region;
 }
@@ -3451,14 +2567,14 @@ cast_region2::compare_fields (const cast_region2 &other) const
 /* FIXME.  */
 
 void
-cast_region2::accept (visitor *v) const
+cast_region::accept (visitor *v) const
 {
-  region2::accept (v);
+  region::accept (v);
   m_original_region->accept (v);
 }
 
 void
-cast_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+cast_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   if (simple)
     {
@@ -3470,7 +2586,7 @@ cast_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
   else
     {
-      pp_string (pp, "cast_region2(");
+      pp_string (pp, "cast_region(");
       m_original_region->dump_to_pp (pp, simple);
       pp_string (pp, ", ");
       print_quoted_type (pp, get_type ());
@@ -3479,47 +2595,47 @@ cast_region2::dump_to_pp (pretty_printer *pp, bool simple) const
 }
 
 void
-cast_region2::add_to_hash (inchash::hash &hstate) const
+cast_region::add_to_hash (inchash::hash &hstate) const
 {
-  region2::add_to_hash (hstate);
+  region::add_to_hash (hstate);
   hstate.add_ptr (m_original_region);
 }
 
-/* class heap_allocated_region2 : public region2.  */
+/* class heap_allocated_region : public region.  */
 
 void
-heap_allocated_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+heap_allocated_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   // TODO:
   if (simple)
     pp_printf (pp, "HEAP_ALLOCATED_REGION(%i)", get_id ());
   else
-    pp_printf (pp, "heap_allocated_region2(%i)", get_id ());
+    pp_printf (pp, "heap_allocated_region(%i)", get_id ());
 }
 
-/* class alloca_region2 : public region2.  */
+/* class alloca_region : public region.  */
 
 void
-alloca_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+alloca_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   // TODO:
   if (simple)
     pp_string (pp, "ALLOCA_REGION");
   else
-    pp_string (pp, "alloca_region2()");
+    pp_string (pp, "alloca_region()");
 }
 
-/* class string_region2 : public region2.  */
+/* class string_region : public region.  */
 
 void
-string_region2::dump_to_pp (pretty_printer *pp, bool simple) const
+string_region::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   // TODO:
   if (simple)
     dump_tree (pp, m_string_cst);
   else
     {
-      pp_string (pp, "string_region2(");
+      pp_string (pp, "string_region(");
       dump_tree (pp, m_string_cst);
       pp_string (pp, " (");
       pp_pointer (pp, m_string_cst);
@@ -3527,17 +2643,17 @@ string_region2::dump_to_pp (pretty_printer *pp, bool simple) const
     }
 }
 
-/* class unknown_region2 : public region2.  */
+/* class unknown_region : public region.  */
 
 void
-unknown_region2::dump_to_pp (pretty_printer *pp, bool /*simple*/) const
+unknown_region::dump_to_pp (pretty_printer *pp, bool /*simple*/) const
 {
   pp_string (pp, "UNKNOWN_REGION");
 }
 
-/* class region_model2_manager.  */
+/* class region_model_manager.  */
 
-region_model2_manager::region_model2_manager ()
+region_model_manager::region_model_manager ()
 : m_next_region_id (0),
   m_root_region (alloc_region_id ()),
   m_stack_region (alloc_region_id (), &m_root_region),
@@ -3553,7 +2669,7 @@ region_model2_manager::region_model2_manager ()
   // TODO
 }
 
-region_model2_manager::~region_model2_manager ()
+region_model_manager::~region_model_manager ()
 {
   /* Delete consolidated svalues.  */
   for (constants_map_t::iterator iter = m_constants_map.begin ();
@@ -3616,7 +2732,7 @@ region_model2_manager::~region_model2_manager ()
 /* Return true if C exceeds the complexity limit for svalues.  */
 
 bool
-region_model2_manager::too_complex_p (const complexity &c) const
+region_model_manager::too_complex_p (const complexity &c) const
 {
   /* TODO: check both num nodes and max_depth
      TODO: use params.  */
@@ -3636,7 +2752,7 @@ region_model2_manager::too_complex_p (const complexity &c) const
    Otherwise update m_max_complexity and return false.  */
 
 bool
-region_model2_manager::reject_if_too_complex (svalue2 *sval)
+region_model_manager::reject_if_too_complex (svalue *sval)
 {
   const complexity &c = sval->get_complexity ();
   if (!too_complex_p (c))
@@ -3663,7 +2779,7 @@ region_model2_manager::reject_if_too_complex (svalue2 *sval)
 }
 
 /* Macro for imposing a complexity limit on svalues, for use within
-   region_model2_manager member functions.
+   region_model_manager member functions.
 
    If SVAL is exceeds the complexity limit, delete it and return an UNKNOWN
    value of the same type.
@@ -3671,128 +2787,128 @@ region_model2_manager::reject_if_too_complex (svalue2 *sval)
 
 #define RETURN_UNKNOWN_IF_TOO_COMPLEX(SVAL)			\
   do {								\
-    svalue2 *sval_ = (SVAL);					\
+    svalue *sval_ = (SVAL);					\
     tree type_ = sval_->get_type ();				\
     if (reject_if_too_complex (sval_))				\
-      return get_or_create_unknown_svalue2 (type_);		\
+      return get_or_create_unknown_svalue (type_);		\
   } while (0)
 
-/* svalue2 consolidation.  */
+/* svalue consolidation.  */
 
-/* Return an svalue2 *for a constant_svalue2 for CST_EXPR,
-   creating the constant_svalue2 if necessary.
-   The constant_svalue2 instances are reused, based on pointer equality
+/* Return an svalue *for a constant_svalue for CST_EXPR,
+   creating the constant_svalue if necessary.
+   The constant_svalue instances are reused, based on pointer equality
    of trees  */
-const svalue2 *
-region_model2_manager::get_or_create_constant_svalue2 (tree cst_expr)
+const svalue *
+region_model_manager::get_or_create_constant_svalue (tree cst_expr)
 {
   gcc_assert (cst_expr);
 
-  constant_svalue2 **slot = m_constants_map.get (cst_expr);
+  constant_svalue **slot = m_constants_map.get (cst_expr);
   if (slot)
     return *slot;
-  constant_svalue2 *cst_sval = new constant_svalue2 (cst_expr);
+  constant_svalue *cst_sval = new constant_svalue (cst_expr);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (cst_sval);
   m_constants_map.put (cst_expr, cst_sval);
   return cst_sval;
   // TODO: cst equality vs tree pointer equality?
 }
 
-/* Return an svalue2 *for a unknown_svalue2 for TYPE (which can be NULL),
-   creating the unknown_svalue2 if necessary.
-   The unknown_svalue2 instances are reused, based on pointer equality
+/* Return an svalue *for a unknown_svalue for TYPE (which can be NULL),
+   creating the unknown_svalue if necessary.
+   The unknown_svalue instances are reused, based on pointer equality
    of trees  */
 
-const svalue2 *
-region_model2_manager::get_or_create_unknown_svalue2 (tree type)
+const svalue *
+region_model_manager::get_or_create_unknown_svalue (tree type)
 {
   /* FIXME: remove this special case in favor of fixing traits to
      allow for a NULL key (as opposed to it being the "empty" value) .  */
   if (type == NULL_TREE)
     {
       if (!m_unknown_NULL)
-	m_unknown_NULL = new unknown_svalue2 (type);
+	m_unknown_NULL = new unknown_svalue (type);
       return m_unknown_NULL;
     }
 
-  unknown_svalue2 **slot = m_unknowns_map.get (type);
+  unknown_svalue **slot = m_unknowns_map.get (type);
   if (slot)
     return *slot;
-  unknown_svalue2 *sval = new unknown_svalue2 (type);
+  unknown_svalue *sval = new unknown_svalue (type);
   m_unknowns_map.put (type, sval);
   return sval;
 }
 
-const svalue2 *
-region_model2_manager::get_or_create_initial_value (const region2 *reg)
+const svalue *
+region_model_manager::get_or_create_initial_value (const region *reg)
 {
   /* The initial value of a cast is a cast of the initial value.  */
-  if (const cast_region2 *cast_reg = reg->dyn_cast_cast_region2 ())
+  if (const cast_region *cast_reg = reg->dyn_cast_cast_region ())
     {
-      const region2 *original_reg = cast_reg->get_original_region ();
+      const region *original_reg = cast_reg->get_original_region ();
       return get_or_create_cast (cast_reg->get_type (),
 				 get_or_create_initial_value (original_reg));
     }
 
-  if (initial_svalue2 **slot = m_initial_values_map.get (reg))
+  if (initial_svalue **slot = m_initial_values_map.get (reg))
     return *slot;
-  initial_svalue2 *initial_sval = new initial_svalue2 (reg->get_type (), reg);
+  initial_svalue *initial_sval = new initial_svalue (reg->get_type (), reg);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (initial_sval);
   m_initial_values_map.put (reg, initial_sval);
   return initial_sval;
 }
 
-const svalue2 *
-region_model2_manager::get_or_create_setjmp_svalue2 (const setjmp_record &r,
-						     tree type)
+const svalue *
+region_model_manager::get_or_create_setjmp_svalue (const setjmp_record &r,
+						   tree type)
 {
-  setjmp_svalue2::key_t key (r, type);
-  if (setjmp_svalue2 **slot = m_setjmp_values_map.get (key))
+  setjmp_svalue::key_t key (r, type);
+  if (setjmp_svalue **slot = m_setjmp_values_map.get (key))
     return *slot;
-  setjmp_svalue2 *setjmp_sval = new setjmp_svalue2 (r, type);
+  setjmp_svalue *setjmp_sval = new setjmp_svalue (r, type);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (setjmp_sval);
   m_setjmp_values_map.put (key, setjmp_sval);
   return setjmp_sval;
 }
 
-const svalue2 *
-region_model2_manager::get_or_create_poisoned_svalue2 (enum poison_kind kind,
-						       tree type)
+const svalue *
+region_model_manager::get_or_create_poisoned_svalue (enum poison_kind kind,
+						     tree type)
 {
-  poisoned_svalue2::key_t key (kind, type);
-  if (poisoned_svalue2 **slot = m_poisoned_values_map.get (key))
+  poisoned_svalue::key_t key (kind, type);
+  if (poisoned_svalue **slot = m_poisoned_values_map.get (key))
     return *slot;
-  poisoned_svalue2 *poisoned_sval = new poisoned_svalue2 (kind, type);
+  poisoned_svalue *poisoned_sval = new poisoned_svalue (kind, type);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (poisoned_sval);
   m_poisoned_values_map.put (key, poisoned_sval);
   return poisoned_sval;
 }
 
-const svalue2 *
-region_model2_manager::get_ptr_svalue2 (tree ptr_type, const region2 *pointee)
+const svalue *
+region_model_manager::get_ptr_svalue (tree ptr_type, const region *pointee)
 {
   /* If this is a symbolic region from dereferencing a pointer, and the types
      match, then return the original pointer.  */
-  if (const symbolic_region2 *sym_reg = pointee->dyn_cast_symbolic_region2 ())
+  if (const symbolic_region *sym_reg = pointee->dyn_cast_symbolic_region ())
     if (ptr_type == sym_reg->get_pointer ()->get_type ())
       return sym_reg->get_pointer ();
 
   // FIXME: use ptr_type here:
-  if (region_svalue2 **slot = m_pointer_values_map.get (pointee))
+  if (region_svalue **slot = m_pointer_values_map.get (pointee))
     return *slot;
-  region_svalue2 *sval = new region_svalue2 (ptr_type, pointee);
+  region_svalue *sval = new region_svalue (ptr_type, pointee);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (sval);
   m_pointer_values_map.put (pointee, sval);
   return sval;
 }
 
-const svalue2 *
-region_model2_manager::maybe_fold_unaryop (tree type, enum tree_code op,
-					   const svalue2 *arg)
+const svalue *
+region_model_manager::maybe_fold_unaryop (tree type, enum tree_code op,
+					   const svalue *arg)
 {
   /* Ops on "unknown" are also unknown.  */
-  if (arg->get_kind () == svalue2::SK_UNKNOWN)
-    return get_or_create_unknown_svalue2 (type);
+  if (arg->get_kind () == svalue::SK_UNKNOWN)
+    return get_or_create_unknown_svalue (type);
 
   switch (op)
     {
@@ -3807,7 +2923,7 @@ region_model2_manager::maybe_fold_unaryop (tree type, enum tree_code op,
 	/* Fold "cast<TYPE> (cast <INNER_TYPE> (innermost_arg))
 	     => "cast<TYPE> (innermost_arg)",
 	   unless INNER_TYPE is narrower than TYPE.  */
-	if (const svalue2 *innermost_arg = arg->maybe_undo_cast ())
+	if (const svalue *innermost_arg = arg->maybe_undo_cast ())
 	  {
 	    tree inner_type = arg->get_type ();
 	    if (TYPE_PRECISION (type) <= TYPE_PRECISION (inner_type))
@@ -3818,7 +2934,7 @@ region_model2_manager::maybe_fold_unaryop (tree type, enum tree_code op,
     case TRUTH_NOT_EXPR:
       {
 	/* Invert comparisons e.g. "!(x == y)" => "x != y".  */
-	if (const binop_svalue2 *binop = arg->dyn_cast_binop_svalue2 ())
+	if (const binop_svalue *binop = arg->dyn_cast_binop_svalue ())
 	  if (TREE_CODE_CLASS (binop->get_op ()) == tcc_comparison)
 	    {
 	      enum tree_code inv_op
@@ -3836,36 +2952,36 @@ region_model2_manager::maybe_fold_unaryop (tree type, enum tree_code op,
   /* Constants.  */
   if (tree cst = arg->maybe_get_constant ())
     if (tree result = fold_unary (op, type, cst))
-      return get_or_create_constant_svalue2 (result);
+      return get_or_create_constant_svalue (result);
 
   return NULL;
 }
 
-const svalue2 *
-region_model2_manager::get_or_create_unaryop (tree type, enum tree_code op,
-					      const svalue2 *arg)
+const svalue *
+region_model_manager::get_or_create_unaryop (tree type, enum tree_code op,
+					      const svalue *arg)
 {
-  if (const svalue2 *folded = maybe_fold_unaryop  (type, op, arg))
+  if (const svalue *folded = maybe_fold_unaryop  (type, op, arg))
     return folded;
-  unaryop_svalue2::key_t key (type, op, arg);
-  if (unaryop_svalue2 **slot = m_unaryop_values_map.get (key))
+  unaryop_svalue::key_t key (type, op, arg);
+  if (unaryop_svalue **slot = m_unaryop_values_map.get (key))
     return *slot;
-  unaryop_svalue2 *unaryop_sval = new unaryop_svalue2 (type, op, arg);
+  unaryop_svalue *unaryop_sval = new unaryop_svalue (type, op, arg);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (unaryop_sval);
   m_unaryop_values_map.put (key, unaryop_sval);
   return unaryop_sval;
 }
 
-const svalue2 *
-region_model2_manager::get_or_create_cast (tree type, const svalue2 *arg)
+const svalue *
+region_model_manager::get_or_create_cast (tree type, const svalue *arg)
 {
   return get_or_create_unaryop (type, NOP_EXPR, arg);
 }
 
-const svalue2 *
-region_model2_manager::maybe_fold_binop (tree type, enum tree_code op,
-					 const svalue2 *arg0,
-					 const svalue2 *arg1)
+const svalue *
+region_model_manager::maybe_fold_binop (tree type, enum tree_code op,
+					 const svalue *arg0,
+					 const svalue *arg1)
 {
   tree cst0 = arg0->maybe_get_constant ();
   tree cst1 = arg1->maybe_get_constant ();
@@ -3874,7 +2990,7 @@ region_model2_manager::maybe_fold_binop (tree type, enum tree_code op,
     {
       if (tree result = fold_binary (op, type, cst0, cst1))
 	if (CONSTANT_CLASS_P (result))
-	  return get_or_create_constant_svalue2 (result);
+	  return get_or_create_constant_svalue (result);
     }
 
   if (FLOAT_TYPE_P (type)
@@ -3901,7 +3017,7 @@ region_model2_manager::maybe_fold_binop (tree type, enum tree_code op,
       /* (VAL * 0).  */
       if (cst1 && zerop (cst1))
 	// FIXME: check for integer type
-	return get_or_create_constant_svalue2 (build_int_cst (type, 0));
+	return get_or_create_constant_svalue (build_int_cst (type, 0));
       /* (VAL * 1) -> VAL.  */
       if (cst1 && integer_onep (cst1))
 	return arg0;
@@ -3912,7 +3028,7 @@ region_model2_manager::maybe_fold_binop (tree type, enum tree_code op,
 	{
 	  if (zerop (cst1))
 	    /* "(ARG0 && 0)" -> "0".  */
-	    return get_or_create_constant_svalue2 (build_int_cst (type, 0));
+	    return get_or_create_constant_svalue (build_int_cst (type, 0));
 	  else
 	    /* "(ARG0 && nonzero-cst)" -> "ARG0".  */
 	    return get_or_create_cast (type, arg0);
@@ -3935,7 +3051,7 @@ region_model2_manager::maybe_fold_binop (tree type, enum tree_code op,
   /* For associative ops, fold "(X op CST_A) op CST_B)" to
      "X op (CST_A op CST_B)".  */
   if (cst1 && associative_tree_code (op))
-    if (const binop_svalue2 *binop = arg0->dyn_cast_binop_svalue2 ())
+    if (const binop_svalue *binop = arg0->dyn_cast_binop_svalue ())
       if (binop->get_op () == op
 	  && binop->get_arg1 ()->maybe_get_constant ()
 	  && type == binop->get_type ()
@@ -3950,9 +3066,9 @@ region_model2_manager::maybe_fold_binop (tree type, enum tree_code op,
      associative_tree_code is false for POINTER_PLUS_EXPR, but we
      can fold:
        "(PTR ptr+ CST_A) ptr+ CST_B)" to "PTR ptr+ (CST_A ptr+ CST_B)".  */
-  /* e.g. in data-model-1.c: test_42c.  */
+  /* e.g. in data-model-1.c: test_4c.  */
   if (cst1 && op == POINTER_PLUS_EXPR)
-    if (const binop_svalue2 *binop = arg0->dyn_cast_binop_svalue2 ())
+    if (const binop_svalue *binop = arg0->dyn_cast_binop_svalue ())
       if (binop->get_op () == POINTER_PLUS_EXPR)
 	if (tree cst01 = binop->get_arg1 ()->maybe_get_constant ())
 	  {
@@ -3964,31 +3080,31 @@ region_model2_manager::maybe_fold_binop (tree type, enum tree_code op,
 
   /* Ops on "unknown" are also unknown (unless we can use one of the
      identities above).  */
-  if (arg0->get_kind () == svalue2::SK_UNKNOWN
-      || arg1->get_kind () == svalue2::SK_UNKNOWN)
-    return get_or_create_unknown_svalue2 (type);
+  if (arg0->get_kind () == svalue::SK_UNKNOWN
+      || arg1->get_kind () == svalue::SK_UNKNOWN)
+    return get_or_create_unknown_svalue (type);
 
   // TODO
 
   return NULL;
 }
 
-const svalue2 *
-region_model2_manager::get_or_create_binop (tree type, enum tree_code op,
-					    const svalue2 *arg0,
-					    const svalue2 *arg1)
+const svalue *
+region_model_manager::get_or_create_binop (tree type, enum tree_code op,
+					    const svalue *arg0,
+					    const svalue *arg1)
 {
   /* For commutative ops, put any constant on the RHS.  */
   if (arg0->maybe_get_constant () && commutative_tree_code (op))
     std::swap (arg0, arg1);
 
-  if (const svalue2 *folded = maybe_fold_binop (type, op, arg0, arg1))
+  if (const svalue *folded = maybe_fold_binop (type, op, arg0, arg1))
     return folded;
 
-  binop_svalue2::key_t key (type, op, arg0, arg1);
-  if (binop_svalue2 **slot = m_binop_values_map.get (key))
+  binop_svalue::key_t key (type, op, arg0, arg1);
+  if (binop_svalue **slot = m_binop_values_map.get (key))
     return *slot;
-  binop_svalue2 *binop_sval = new binop_svalue2 (type, op, arg0, arg1);
+  binop_svalue *binop_sval = new binop_svalue (type, op, arg0, arg1);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (binop_sval);
   m_binop_values_map.put (key, binop_sval);
   return binop_sval;
@@ -3996,9 +3112,9 @@ region_model2_manager::get_or_create_binop (tree type, enum tree_code op,
 
 /* FIXME.  */
 
-static const svalue2 *
+static const svalue *
 maybe_get_char_from_string_cst (tree string_cst, tree byte_offset_cst,
-				region_model2_manager *mgr)
+				region_model_manager *mgr)
 {
   gcc_assert (TREE_CODE (string_cst) == STRING_CST);
 
@@ -4015,46 +3131,46 @@ maybe_get_char_from_string_cst (tree string_cst, tree byte_offset_cst,
 	= build_int_cst_type (TREE_TYPE (TREE_TYPE (string_cst)),
 			      (TREE_STRING_POINTER (string_cst)
 			       [TREE_INT_CST_LOW (byte_offset_cst)]));
-      return mgr->get_or_create_constant_svalue2 (char_cst);
+      return mgr->get_or_create_constant_svalue (char_cst);
     }
   return NULL;
 }
 
-/* Subroutine of region_model2_manager::get_or_create_sub_svalue2.
-   Return a folded svalue2, or NULL.  */
+/* Subroutine of region_model_manager::get_or_create_sub_svalue.
+   Return a folded svalue, or NULL.  */
 
-const svalue2 *
-region_model2_manager::maybe_fold_sub_svalue2 (tree type,
-					       const svalue2 *parent_svalue2,
-					       const region2 *subregion)
+const svalue *
+region_model_manager::maybe_fold_sub_svalue (tree type,
+					     const svalue *parent_svalue,
+					     const region *subregion)
 {
   /* Subvalues of "unknown" are unknown.  */
-  if (parent_svalue2->get_kind () == svalue2::SK_UNKNOWN)
-    return get_or_create_unknown_svalue2 (type);
+  if (parent_svalue->get_kind () == svalue::SK_UNKNOWN)
+    return get_or_create_unknown_svalue (type);
 
   /* If we have a subregion of a zero-fill, it's zero.  */
-  if (const unaryop_svalue2 *unary
-      = parent_svalue2->dyn_cast_unaryop_svalue2 ())
+  if (const unaryop_svalue *unary
+      = parent_svalue->dyn_cast_unaryop_svalue ())
     {
       if (unary->get_op () == NOP_EXPR)
 	if (tree cst = unary->get_arg ()->maybe_get_constant ())
 	  if (zerop (cst))
 	    {
-	      const svalue2 *cst_sval
-		= get_or_create_constant_svalue2 (cst);
+	      const svalue *cst_sval
+		= get_or_create_constant_svalue (cst);
 	      return get_or_create_cast (type, cst_sval);
 	    }
     }
 
   /* Handle getting individual chars from a STRING_CST.  */
-  if (tree cst = parent_svalue2->maybe_get_constant ())
+  if (tree cst = parent_svalue->maybe_get_constant ())
     if (TREE_CODE (cst) == STRING_CST)
-      if (const element_region2 *element_reg
-	    = subregion->dyn_cast_element_region2 ())
+      if (const element_region *element_reg
+	    = subregion->dyn_cast_element_region ())
 	{
-	  const svalue2 *idx_sval = element_reg->get_index ();
+	  const svalue *idx_sval = element_reg->get_index ();
 	  if (tree cst_idx = idx_sval->maybe_get_constant ())
-	    if (const svalue2 *char_sval
+	    if (const svalue *char_sval
 		= maybe_get_char_from_string_cst (cst, cst_idx, this))
 	      return get_or_create_cast (type, char_sval);
 	}
@@ -4063,12 +3179,12 @@ region_model2_manager::maybe_fold_sub_svalue2 (tree type,
      i.e.
      Subvalue(InitialValue(R1), FieldRegion(R2, F))
        -> InitialValue(FieldRegion(R1, F)).  */
-  if (const initial_svalue2 *init_sval
-        = parent_svalue2->dyn_cast_initial_svalue2 ())
+  if (const initial_svalue *init_sval
+        = parent_svalue->dyn_cast_initial_svalue ())
     {
-      if (const field_region2 *field_reg = subregion->dyn_cast_field_region2 ())
+      if (const field_region *field_reg = subregion->dyn_cast_field_region ())
 	{
-	  const region2 *field_reg_new
+	  const region *field_reg_new
 	    = get_field_region (init_sval->get_region (),
 				field_reg->get_field ());
 	  return get_or_create_initial_value (field_reg_new);
@@ -4081,20 +3197,20 @@ region_model2_manager::maybe_fold_sub_svalue2 (tree type,
 
 /* FIXME.  */
 
-const svalue2 *
-region_model2_manager::get_or_create_sub_svalue2 (tree type,
-						  const svalue2 *parent_svalue2,
-						  const region2 *subregion)
+const svalue *
+region_model_manager::get_or_create_sub_svalue (tree type,
+						const svalue *parent_svalue,
+						const region *subregion)
 {
-  if (const svalue2 *folded
-	= maybe_fold_sub_svalue2 (type, parent_svalue2, subregion))
+  if (const svalue *folded
+	= maybe_fold_sub_svalue (type, parent_svalue, subregion))
     return folded;
 
-  sub_svalue2::key_t key (type, parent_svalue2, subregion);
-  if (sub_svalue2 **slot = m_sub_values_map.get (key))
+  sub_svalue::key_t key (type, parent_svalue, subregion);
+  if (sub_svalue **slot = m_sub_values_map.get (key))
     return *slot;
-  sub_svalue2 *sub_sval
-    = new sub_svalue2 (type, parent_svalue2, subregion);
+  sub_svalue *sub_sval
+    = new sub_svalue (type, parent_svalue, subregion);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (sub_sval);
   m_sub_values_map.put (key, sub_sval);
   return sub_sval;
@@ -4102,15 +3218,15 @@ region_model2_manager::get_or_create_sub_svalue2 (tree type,
 
 /* FIXME.  */
 
-const svalue2 *
-region_model2_manager::get_or_create_unmergeable (const svalue2 *arg)
+const svalue *
+region_model_manager::get_or_create_unmergeable (const svalue *arg)
 {
-  if (arg->get_kind () == svalue2::SK_UNMERGEABLE)
+  if (arg->get_kind () == svalue::SK_UNMERGEABLE)
     return arg;
 
-  if (unmergeable_svalue2 **slot = m_unmergeable_values_map.get (arg))
+  if (unmergeable_svalue **slot = m_unmergeable_values_map.get (arg))
     return *slot;
-  unmergeable_svalue2 *unmergeable_sval = new unmergeable_svalue2 (arg);
+  unmergeable_svalue *unmergeable_sval = new unmergeable_svalue (arg);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (unmergeable_sval);
   m_unmergeable_values_map.put (arg, unmergeable_sval);
   return unmergeable_sval;
@@ -4118,17 +3234,17 @@ region_model2_manager::get_or_create_unmergeable (const svalue2 *arg)
 
 /* FIXME.  */
 
-const svalue2 *
-region_model2_manager::get_or_create_widening_svalue2 (tree type,
-						       const program_point &point,
-						       const svalue2 *base_sval,
-						       const svalue2 *iter_sval)
+const svalue *
+region_model_manager::get_or_create_widening_svalue (tree type,
+						     const program_point &point,
+						     const svalue *base_sval,
+						     const svalue *iter_sval)
 {
-  widening_svalue2::key_t key (type, point, base_sval, iter_sval);
-  if (widening_svalue2 **slot = m_widening_values_map.get (key))
+  widening_svalue::key_t key (type, point, base_sval, iter_sval);
+  if (widening_svalue **slot = m_widening_values_map.get (key))
     return *slot;
-  widening_svalue2 *widening_sval
-    = new widening_svalue2 (type, point, base_sval, iter_sval);
+  widening_svalue *widening_sval
+    = new widening_svalue (type, point, base_sval, iter_sval);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (widening_sval);
   m_widening_values_map.put (key, widening_sval);
   return widening_sval;
@@ -4136,16 +3252,16 @@ region_model2_manager::get_or_create_widening_svalue2 (tree type,
 
 /* FIXME.  */
 
-const svalue2 *
-region_model2_manager::
-get_or_create_compound_svalue2 (tree type,
+const svalue *
+region_model_manager::
+get_or_create_compound_svalue (tree type,
 				const binding_map &map)
 {
-  compound_svalue2::key_t tmp_key (type, &map);
-  if (compound_svalue2 **slot = m_compound_values_map.get (tmp_key))
+  compound_svalue::key_t tmp_key (type, &map);
+  if (compound_svalue **slot = m_compound_values_map.get (tmp_key))
     return *slot;
-  compound_svalue2 *compound_sval
-    = new compound_svalue2 (type, map);
+  compound_svalue *compound_sval
+    = new compound_svalue (type, map);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (compound_sval);
   /* Use make_key rather than reusing the key, so that we use a
      ptr to compound_sval's binding_map, rather than the MAP param.  */
@@ -4155,105 +3271,105 @@ get_or_create_compound_svalue2 (tree type,
 
 /* FIXME.  */
 
-const svalue2 *
-region_model2_manager::
-get_or_create_conjured_svalue2 (tree type, const gimple *stmt,
-				const region2 *id_reg)
+const svalue *
+region_model_manager::
+get_or_create_conjured_svalue (tree type, const gimple *stmt,
+				const region *id_reg)
 {
-  conjured_svalue2::key_t key (type, stmt, id_reg);
-  if (conjured_svalue2 **slot = m_conjured_values_map.get (key))
+  conjured_svalue::key_t key (type, stmt, id_reg);
+  if (conjured_svalue **slot = m_conjured_values_map.get (key))
     return *slot;
-  conjured_svalue2 *conjured_sval
-    = new conjured_svalue2 (type, stmt, id_reg);
+  conjured_svalue *conjured_sval
+    = new conjured_svalue (type, stmt, id_reg);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (conjured_sval);
   m_conjured_values_map.put (key, conjured_sval);
   return conjured_sval;
 }
 
-/* region2 consolidation.  */
+/* region consolidation.  */
 
 /* FIXME.  */
 
-const function_region2 *
-region_model2_manager::get_region_for_fndecl (tree fndecl)
+const function_region *
+region_model_manager::get_region_for_fndecl (tree fndecl)
 {
   gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL);
 
-  function_region2 **slot = m_fndecls_map.get (fndecl);
+  function_region **slot = m_fndecls_map.get (fndecl);
   if (slot)
     return *slot;
-  function_region2 *reg
-    = new function_region2 (alloc_region_id (), &m_code_region, fndecl);
+  function_region *reg
+    = new function_region (alloc_region_id (), &m_code_region, fndecl);
   m_fndecls_map.put (fndecl, reg);
   return reg;
 }
 
 /* FIXME.  */
 
-const label_region2 *
-region_model2_manager::get_region_for_label (tree label)
+const label_region *
+region_model_manager::get_region_for_label (tree label)
 {
   gcc_assert (TREE_CODE (label) == LABEL_DECL);
 
-  label_region2 **slot = m_labels_map.get (label);
+  label_region **slot = m_labels_map.get (label);
   if (slot)
     return *slot;
 
   tree fndecl = DECL_CONTEXT (label);
   gcc_assert (fndecl && TREE_CODE (fndecl) == FUNCTION_DECL);
 
-  const function_region2 *func_reg = get_region_for_fndecl (fndecl);
-  label_region2 *reg
-    = new label_region2 (alloc_region_id (), func_reg, label);
+  const function_region *func_reg = get_region_for_fndecl (fndecl);
+  label_region *reg
+    = new label_region (alloc_region_id (), func_reg, label);
   m_labels_map.put (label, reg);
   return reg;
 }
 
 /* FIXME.  */
 
-const decl_region2 *
-region_model2_manager::get_region_for_global (tree expr)
+const decl_region *
+region_model_manager::get_region_for_global (tree expr)
 {
   gcc_assert (TREE_CODE (expr) == VAR_DECL);
 
-  decl_region2 **slot = m_globals_map.get (expr);
+  decl_region **slot = m_globals_map.get (expr);
   if (slot)
     return *slot;
-  decl_region2 *reg
-    = new decl_region2 (alloc_region_id (), &m_globals_region, expr);
+  decl_region *reg
+    = new decl_region (alloc_region_id (), &m_globals_region, expr);
   m_globals_map.put (expr, reg);
   return reg;
 }
 
 /* FIXME.  */
 
-const region2 *
-region_model2_manager::get_field_region (const region2 *parent, tree field)
+const region *
+region_model_manager::get_field_region (const region *parent, tree field)
 {
   // FIXME: should only alloc_region_id if consolidation fails
-  region2 *field_reg = new field_region2 (alloc_region_id (), parent, field);
-  return const_cast <region2 *> (m_fields.consolidate (field_reg));
+  region *field_reg = new field_region (alloc_region_id (), parent, field);
+  return const_cast <region *> (m_fields.consolidate (field_reg));
 }
 
 /* FIXME.  */
 
-const region2 *
-region_model2_manager::get_element_region (const region2 *parent,
+const region *
+region_model_manager::get_element_region (const region *parent,
 					   tree element_type,
-					   const svalue2 *index)
+					   const svalue *index)
 {
   // FIXME: should only alloc_region_id if consolidation fails
-  region2 *element_reg
-    = new element_region2 (alloc_region_id (), parent, element_type, index);
-  return const_cast <region2 *> (m_elements.consolidate (element_reg));
+  region *element_reg
+    = new element_region (alloc_region_id (), parent, element_type, index);
+  return const_cast <region *> (m_elements.consolidate (element_reg));
 }
 
 /* FIXME.  */
 
-const region2 *
-region_model2_manager::get_offset_region (const region2 *parent,
+const region *
+region_model_manager::get_offset_region (const region *parent,
 					  tree type,
-					  const svalue2 *byte_offset)
+					  const svalue *byte_offset)
 {
   /* If BYTE_OFFSET is zero, return PARENT.  */
   if (tree cst_offset = byte_offset->maybe_get_constant ())
@@ -4262,26 +3378,26 @@ region_model2_manager::get_offset_region (const region2 *parent,
 
   /* Fold OFFSET_REGION(OFFSET_REGION(REG, X), Y)
      to   OFFSET_REGION(REG, (X + Y)).  */
-  if (const offset_region2 *parent_offset_reg
-	= parent->dyn_cast_offset_region2 ())
+  if (const offset_region *parent_offset_reg
+	= parent->dyn_cast_offset_region ())
     {
-      const svalue2 *sval_x = parent_offset_reg->get_byte_offset ();
-      const svalue2 *sval_sum
+      const svalue *sval_x = parent_offset_reg->get_byte_offset ();
+      const svalue *sval_sum
 	= get_or_create_binop (byte_offset->get_type (),
 			       PLUS_EXPR, sval_x, byte_offset);
       return get_offset_region (parent->get_parent_region (), type, sval_sum);
     }
 
   // FIXME: should only alloc_region_id if consolidation fails
-  region2 *offset_reg
-    = new offset_region2 (alloc_region_id (), parent, type, byte_offset);
-  return const_cast <region2 *> (m_offset_regions.consolidate (offset_reg));
+  region *offset_reg
+    = new offset_region (alloc_region_id (), parent, type, byte_offset);
+  return const_cast <region *> (m_offset_regions.consolidate (offset_reg));
 }
 
 /* FIXME.  */
 
-const region2 *
-region_model2_manager::get_cast_region (const region2 *original_region,
+const region *
+region_model_manager::get_cast_region (const region *original_region,
 					tree type)
 {
   /* If types match, return ORIGINAL_REGION.  */
@@ -4289,70 +3405,70 @@ region_model2_manager::get_cast_region (const region2 *original_region,
     return original_region;
 
   // FIXME: should only alloc_region_id if consolidation fails
-  region2 *cast_reg
-    = new cast_region2 (alloc_region_id (), original_region, type);
-  return const_cast <region2 *> (m_cast_regions.consolidate (cast_reg));
+  region *cast_reg
+    = new cast_region (alloc_region_id (), original_region, type);
+  return const_cast <region *> (m_cast_regions.consolidate (cast_reg));
 }
 
 /* FIXME.  */
 
-const frame_region2 *
-region_model2_manager::get_frame_region (const frame_region2 *calling_frame,
+const frame_region *
+region_model_manager::get_frame_region (const frame_region *calling_frame,
 					 function *fun)
 {
   int index = calling_frame ? calling_frame->get_index () + 1 : 0;
   // FIXME: should only alloc_region_id if consolidation fails
-  frame_region2 *frame_reg
-    = new frame_region2 (alloc_region_id (), &m_stack_region, calling_frame,
+  frame_region *frame_reg
+    = new frame_region (alloc_region_id (), &m_stack_region, calling_frame,
 			 fun, index);
-  return const_cast <frame_region2 *> (m_frames.consolidate (frame_reg));
+  return const_cast <frame_region *> (m_frames.consolidate (frame_reg));
 }
 
 /* FIXME.  */
 
-const region2 *
-region_model2_manager::get_symbolic_region (const svalue2 *sval)
+const region *
+region_model_manager::get_symbolic_region (const svalue *sval)
 {
   // FIXME: should only alloc_region_id if consolidation fails
-  region2 *reg
-    = new symbolic_region2 (alloc_region_id (), &m_root_region, sval);
-  return const_cast <region2 *> (m_symbolic_regions.consolidate (reg));
+  region *reg
+    = new symbolic_region (alloc_region_id (), &m_root_region, sval);
+  return const_cast <region *> (m_symbolic_regions.consolidate (reg));
 }
 
 /* FIXME.  */
 
-const string_region2 *
-region_model2_manager::get_region_for_string (tree string_cst)
+const string_region *
+region_model_manager::get_region_for_string (tree string_cst)
 {
   gcc_assert (TREE_CODE (string_cst) == STRING_CST);
 
-  string_region2 **slot = m_string_map.get (string_cst);
+  string_region **slot = m_string_map.get (string_cst);
   if (slot)
     return *slot;
-  string_region2 *reg
-    = new string_region2 (alloc_region_id (), &m_root_region, string_cst);
+  string_region *reg
+    = new string_region (alloc_region_id (), &m_root_region, string_cst);
   // FIXME: is there a better choice of parent region?
   m_string_map.put (string_cst, reg);
   return reg;
 }
 
 /* If we see a tree code we don't know how to handle, rather than
-   ICE or generate bogus results, create a dummy region2, and notify
+   ICE or generate bogus results, create a dummy region, and notify
    CTXT so that it can mark the new state as being not properly
    modelled.  The exploded graph can then stop exploring that path,
    since any diagnostics we might issue will have questionable
    validity.  */
 
-const region2 *
-region_model2_manager::
-get_region2_for_unexpected_tree_code (region_model2_context *ctxt,
+const region *
+region_model_manager::
+get_region_for_unexpected_tree_code (region_model_context *ctxt,
 				      tree t,
 				      const dump_location_t &loc)
 {
   gcc_assert (ctxt);
   tree type = TYPE_P (t) ? t : TREE_TYPE (t);
-  region2 *new_reg
-    = new unknown_region2 (alloc_region_id (), &m_root_region, type); // FIXME
+  region *new_reg
+    = new unknown_region (alloc_region_id (), &m_root_region, type); // FIXME
   // or should this be something else?
   ctxt->on_unexpected_tree_code (t, loc);
   return new_reg;
@@ -4360,12 +3476,12 @@ get_region2_for_unexpected_tree_code (region_model2_context *ctxt,
 
 /* FIXME.  */
 
-const region2 *
-region_model2_manager::create_region_for_heap_alloc ()
+const region *
+region_model_manager::create_region_for_heap_alloc ()
 {
   // FIXME: should this be a symbolic region??
-  region2 *reg
-    = new heap_allocated_region2 (alloc_region_id (), &m_heap_region);
+  region *reg
+    = new heap_allocated_region (alloc_region_id (), &m_heap_region);
   m_managed_dynamic_regions.safe_push (reg);
   // TODO: selftest; verify no leak under valgrind
   return reg;
@@ -4375,10 +3491,10 @@ region_model2_manager::create_region_for_heap_alloc ()
 
 /* FIXME.  */
 
-const region2 *
-region_model2_manager::create_region_for_alloca (const frame_region2 *frame)
+const region *
+region_model_manager::create_region_for_alloca (const frame_region *frame)
 {
-  region2 *reg = new alloca_region2 (alloc_region_id (), frame);
+  region *reg = new alloca_region (alloc_region_id (), frame);
   m_managed_dynamic_regions.safe_push (reg);
   // TODO: selftest; verify no leak under valgrind
   return reg;
@@ -4401,7 +3517,7 @@ log_managed_object (logger *logger, const T *obj)
 
 template <>
 void
-log_managed_object (logger *logger, const frame_region2 *obj)
+log_managed_object (logger *logger, const frame_region *obj)
 {
   logger->start_log_line ();
   pretty_printer *pp = logger->get_printer ();
@@ -4448,43 +3564,43 @@ log_uniq_manager (logger *logger, bool show_objs, const char *title,
 /* FIXME.  */
 
 void
-region_model2_manager::log_stats (logger *logger, bool show_objs) const
+region_model_manager::log_stats (logger *logger, bool show_objs) const
 {
   LOG_SCOPE (logger);
-  logger->log ("svalue2 consolidation");
-  log_uniq_map (logger, show_objs, "constant_svalue2", m_constants_map);
-  log_uniq_map (logger, show_objs, "unknown_svalue2", m_unknowns_map);
+  logger->log ("svalue consolidation");
+  log_uniq_map (logger, show_objs, "constant_svalue", m_constants_map);
+  log_uniq_map (logger, show_objs, "unknown_svalue", m_unknowns_map);
   if (m_unknown_NULL)
     log_managed_object (logger, m_unknown_NULL);
-  log_uniq_map (logger, show_objs, "poisoned_svalue2", m_poisoned_values_map);
-  log_uniq_map (logger, show_objs, "setjmp_svalue2", m_setjmp_values_map);
-  log_uniq_map (logger, show_objs, "initial_svalue2", m_initial_values_map);
-  log_uniq_map (logger, show_objs, "region_svalue2", m_pointer_values_map);
-  log_uniq_map (logger, show_objs, "unaryop_svalue2", m_unaryop_values_map);
-  log_uniq_map (logger, show_objs, "binop_svalue2", m_binop_values_map);
-  log_uniq_map (logger, show_objs, "sub_svalue2", m_sub_values_map);
-  log_uniq_map (logger, show_objs, "unmergeable_svalue2",
+  log_uniq_map (logger, show_objs, "poisoned_svalue", m_poisoned_values_map);
+  log_uniq_map (logger, show_objs, "setjmp_svalue", m_setjmp_values_map);
+  log_uniq_map (logger, show_objs, "initial_svalue", m_initial_values_map);
+  log_uniq_map (logger, show_objs, "region_svalue", m_pointer_values_map);
+  log_uniq_map (logger, show_objs, "unaryop_svalue", m_unaryop_values_map);
+  log_uniq_map (logger, show_objs, "binop_svalue", m_binop_values_map);
+  log_uniq_map (logger, show_objs, "sub_svalue", m_sub_values_map);
+  log_uniq_map (logger, show_objs, "unmergeable_svalue",
 		m_unmergeable_values_map);
-  log_uniq_map (logger, show_objs, "widening_svalue2", m_widening_values_map);
-  log_uniq_map (logger, show_objs, "compound_svalue2", m_compound_values_map);
-  log_uniq_map (logger, show_objs, "conjured_svalue2", m_conjured_values_map);
+  log_uniq_map (logger, show_objs, "widening_svalue", m_widening_values_map);
+  log_uniq_map (logger, show_objs, "compound_svalue", m_compound_values_map);
+  log_uniq_map (logger, show_objs, "conjured_svalue", m_conjured_values_map);
   logger->log ("max accepted svalue num_nodes: %i",
 	       m_max_complexity.m_num_nodes);
   logger->log ("max accepted svalue max_depth: %i",
 	       m_max_complexity.m_max_depth);
 
-  logger->log ("region2 consolidation");
+  logger->log ("region consolidation");
   logger->log ("  next region id: %i", m_next_region_id);
-  log_uniq_map (logger, show_objs, "function_region2", m_fndecls_map);
-  log_uniq_map (logger, show_objs, "label_region2", m_labels_map);
-  log_uniq_map (logger, show_objs, "decl_region2 for globals", m_globals_map);
-  log_uniq_manager (logger, show_objs, "field_region2", m_fields);
-  log_uniq_manager (logger, show_objs, "element_region2", m_elements);
-  log_uniq_manager (logger, show_objs, "offset_region2", m_offset_regions);
-  log_uniq_manager (logger, show_objs, "cast_region2", m_cast_regions);
-  log_uniq_manager (logger, show_objs, "frame_region2", m_frames);
-  log_uniq_manager (logger, show_objs, "symbolic_region2", m_symbolic_regions);
-  log_uniq_map (logger, show_objs, "string_region2", m_string_map);
+  log_uniq_map (logger, show_objs, "function_region", m_fndecls_map);
+  log_uniq_map (logger, show_objs, "label_region", m_labels_map);
+  log_uniq_map (logger, show_objs, "decl_region for globals", m_globals_map);
+  log_uniq_manager (logger, show_objs, "field_region", m_fields);
+  log_uniq_manager (logger, show_objs, "element_region", m_elements);
+  log_uniq_manager (logger, show_objs, "offset_region", m_offset_regions);
+  log_uniq_manager (logger, show_objs, "cast_region", m_cast_regions);
+  log_uniq_manager (logger, show_objs, "frame_region", m_frames);
+  log_uniq_manager (logger, show_objs, "symbolic_region", m_symbolic_regions);
+  log_uniq_map (logger, show_objs, "string_region", m_string_map);
   logger->log ("  # managed dynamic regions: %i",
 	       m_managed_dynamic_regions.length ());
   m_store_mgr.log_stats (logger, show_objs);
@@ -4497,68 +3613,68 @@ void
 store_manager::log_stats (logger *logger, bool show_objs) const
 {
   LOG_SCOPE (logger);
-  log_uniq_manager (logger, show_objs, "concrete_binding2",
+  log_uniq_manager (logger, show_objs, "concrete_binding",
 		    m_concrete_binding_key_mgr);
-  log_uniq_manager (logger, show_objs, "symbolic_binding2",
+  log_uniq_manager (logger, show_objs, "symbolic_binding",
 		    m_symbolic_binding_key_mgr);
 }
 
-/* class region_model2.  */
+/* class region_model.  */
 
-/* FIXME: region_model2's default ctor.  */
+/* FIXME: region_model's default ctor.  */
 
-region_model2::region_model2 (region_model2_manager *mgr)
+region_model::region_model (region_model_manager *mgr)
 : m_mgr (mgr), m_store (), m_current_frame (NULL)
 {
-  //m_root_reg = add_region2 (new root_region2 ());
-  m_constraints2 = new constraint_manager2 (mgr);
+  //m_root_reg = add_region (new root_region ());
+  m_constraints = new constraint_manager (mgr);
   // TODO
 }
 
-/* region_model2's copy ctor.  */
+/* region_model's copy ctor.  */
 
-region_model2::region_model2 (const region_model2 &other)
+region_model::region_model (const region_model &other)
 : m_mgr (other.m_mgr), m_store (other.m_store),
-  m_constraints2 (new constraint_manager2 (*other.m_constraints2)),
+  m_constraints (new constraint_manager (*other.m_constraints)),
   m_current_frame (other.m_current_frame)
 {
 }
 
-/* region_model2's dtor.  */
+/* region_model's dtor.  */
 
-region_model2::~region_model2 ()
+region_model::~region_model ()
 {
   // empty?
-  delete m_constraints2;
+  delete m_constraints;
 }
 
-/* region_model2's assignment operator.  */
+/* region_model's assignment operator.  */
 
-region_model2 &
-region_model2::operator= (const region_model2 &other)
+region_model &
+region_model::operator= (const region_model &other)
 {
   /* m_mgr is const.  */
   gcc_assert (m_mgr == other.m_mgr);
 
   m_store = other.m_store;
 
-  delete m_constraints2;
-  m_constraints2 = new constraint_manager2 (*other.m_constraints2);
+  delete m_constraints;
+  m_constraints = new constraint_manager (*other.m_constraints);
 
   m_current_frame = other.m_current_frame;
 
   return *this;
 }
 
-/* Equality operator for region_model2.
+/* Equality operator for region_model.
 
    FIXME:
-   Amongst other things this directly compares the svalue2 and region2
+   Amongst other things this directly compares the svalue and region
    vectors and so for this to be meaningful both this and OTHER should
    have been canonicalized.  */
 
 bool
-region_model2::operator== (const region_model2 &other) const
+region_model::operator== (const region_model &other) const
 {
   /* We can only compare instances that use the same manager.  */
   gcc_assert (m_mgr == other.m_mgr);
@@ -4566,7 +3682,7 @@ region_model2::operator== (const region_model2 &other) const
   if (m_store != other.m_store)
     return false;
 
-  if (*m_constraints2 != *other.m_constraints2)
+  if (*m_constraints != *other.m_constraints)
     return false;
 
   if (m_current_frame != other.m_current_frame)
@@ -4577,130 +3693,32 @@ region_model2::operator== (const region_model2 &other) const
   return true;
 }
 
-/* Generate a hash value for this region_model2.  */
+/* Generate a hash value for this region_model.  */
 
 #if 0
 hashval_t
-region_model2::hash () const
+region_model::hash () const
 {
   hashval_t result = 0;
   int i;
 
-  const svalue2 *svalue2;
-  FOR_EACH_VEC_ELT (m_svalue2s, i, svalue2)
-    result ^= svalue2->hash ();
+  const svalue *svalue;
+  FOR_EACH_VEC_ELT (m_svalues, i, svalue)
+    result ^= svalue->hash ();
 
-  region2 *region2;
-  FOR_EACH_VEC_ELT (m_region2s, i, region2)
-    result ^= region2->hash ();
+  region *region;
+  FOR_EACH_VEC_ELT (m_regions, i, region)
+    result ^= region->hash ();
 
   result ^= m_constraints->hash ();
 
   return result;
 }
-
-/* Print an all-on-one-line representation of this region_model2 to PP,
-   which must support %E for trees.  */
-
-void
-region_model2::print (pretty_printer *pp) const
-{
-  int i;
-
-  pp_string (pp, "svalue2s: [");
-  const svalue2 *svalue2;
-  FOR_EACH_VEC_ELT (m_svalue2s, i, svalue2)
-    {
-      if (i > 0)
-	pp_string (pp, ", ");
-      print_svalue2 (svalue2_id::from_int (i), pp);
-    }
-
-  pp_string (pp, "], region2s: [");
-
-  region2 *region2;
-  FOR_EACH_VEC_ELT (m_region2s, i, region2)
-    {
-      if (i > 0)
-	pp_string (pp, ", ");
-      region2->print (*this, region2_id::from_int (i), pp);
-    }
-
-  pp_string (pp, "], constraints: ");
-
-  m_constraints->print (pp);
-}
-
-/* Print the svalue2 with id SID to PP.  */
-
-void
-region_model2::print_svalue2 (const svalue2 *sval, pretty_printer *pp) const
-{
-  get_svalue2 (sid)->print (*this, sid, pp);
-}
-
-/* Dump a .dot representation of this region_model2 to PP, showing
-   the values and the hierarchy of region2s.  */
-
-void
-region_model2::dump_dot_to_pp (pretty_printer *pp) const
-{
-  graphviz_out gv (pp);
-
-  pp_string (pp, "digraph \"");
-  pp_write_text_to_stream (pp);
-  pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/false);
-  pp_string (pp, "\" {\n");
-
-  gv.indent ();
-
-  pp_string (pp, "overlap=false;\n");
-  pp_string (pp, "compound=true;\n");
-
-  int i;
-
-  const svalue2 *svalue2;
-  FOR_EACH_VEC_ELT (m_svalue2s, i, svalue2)
-    svalue2->dump_dot_to_pp (*this, svalue2_id::from_int (i), pp);
-
-  region2 *region2;
-  FOR_EACH_VEC_ELT (m_region2s, i, region2)
-    region2->dump_dot_to_pp (*this, region2_id::from_int (i), pp);
-
-  /* TODO: constraints.  */
-
-  /* Terminate "digraph" */
-  gv.outdent ();
-  pp_string (pp, "}");
-  pp_newline (pp);
-}
-
-/* Dump a .dot representation of this region_model2 to FP.  */
-
-void
-region_model2::dump_dot_to_file (FILE *fp) const
-{
-  pretty_printer pp;
-  pp_format_decoder (&pp) = default_tree_printer;
-  pp.buffer->stream = fp;
-  dump_dot_to_pp (&pp);
-  pp_flush (&pp);
-}
-
-/* Dump a .dot representation of this region_model2 to PATH.  */
-
-void
-region_model2::dump_dot (const char *path) const
-{
-  FILE *fp = fopen (path, "w");
-  dump_dot_to_file (fp);
-  fclose (fp);
-}
 #endif
 
 // FIXME:
 /* Dump a representation of this model to PP, showing the
-   region2 hierarchy, the svalue2s, and any constraints.
+   region hierarchy, the svalues, and any constraints.
 
    If SIMPLE is true, show only the most pertinent information,
    in a form that attempts to be less verbose.
@@ -4709,7 +3727,7 @@ region_model2::dump_dot (const char *path) const
    If MULTILINE... FIXME.  */
 
 void
-region_model2::dump_to_pp (pretty_printer *pp, bool simple,
+region_model::dump_to_pp (pretty_printer *pp, bool simple,
 			   bool multiline) const
 {
   /* Dump stack.  */
@@ -4718,7 +3736,7 @@ region_model2::dump_to_pp (pretty_printer *pp, bool simple,
     pp_newline (pp);
   else
     pp_string (pp, " {");
-  for (const frame_region2 *iter_frame = m_current_frame; iter_frame;
+  for (const frame_region *iter_frame = m_current_frame; iter_frame;
        iter_frame = iter_frame->get_calling_frame ())
     {
       if (multiline)
@@ -4742,12 +3760,12 @@ region_model2::dump_to_pp (pretty_printer *pp, bool simple,
     pp_string (pp, "}");
 
   /* Dump constraints.  */
-  pp_string (pp, "constraint_manager2:");
+  pp_string (pp, "constraint_manager:");
   if (multiline)
     pp_newline (pp);
   else
     pp_string (pp, " {");
-  m_constraints2->dump_to_pp (pp, multiline);
+  m_constraints->dump_to_pp (pp, multiline);
   if (!multiline)
     pp_string (pp, "}");
 }
@@ -4755,7 +3773,7 @@ region_model2::dump_to_pp (pretty_printer *pp, bool simple,
 /* Dump a representation of this model to FILE.  */
 
 void
-region_model2::dump (FILE *fp, bool simple, bool multiline) const
+region_model::dump (FILE *fp, bool simple, bool multiline) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -4769,7 +3787,7 @@ region_model2::dump (FILE *fp, bool simple, bool multiline) const
 /* Dump a multiline representation of this model to stderr.  */
 
 DEBUG_FUNCTION void
-region_model2::dump (bool simple) const
+region_model::dump (bool simple) const
 {
   dump (stderr, simple, true);
 }
@@ -4777,19 +3795,19 @@ region_model2::dump (bool simple) const
 /* Dump a summary of this model to PP.  */
 
 void
-region_model2::summarize_to_pp (pretty_printer *pp, bool simple) const
+region_model::summarize_to_pp (pretty_printer *pp, bool simple) const
 {
   m_store.summarize_to_pp (pp, simple);
 
   // FIXME:
 #if 0
   /* Dump constraints.  */
-  pp_string (pp, "constraint_manager2:");
+  pp_string (pp, "constraint_manager:");
   if (multiline)
     pp_newline (pp);
   else
     pp_string (pp, " {");
-  m_constraints2->dump_to_pp (pp, multiline);
+  m_constraints->dump_to_pp (pp, multiline);
   if (!multiline)
     pp_string (pp, "}");
 #endif
@@ -4798,7 +3816,7 @@ region_model2::summarize_to_pp (pretty_printer *pp, bool simple) const
 /* Dump a summary of this model to stderr.  */
 
 DEBUG_FUNCTION void
-region_model2::summarize (bool simple) const
+region_model::summarize (bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -4812,7 +3830,7 @@ region_model2::summarize (bool simple) const
 /* Dump a multiline representation of this model to stderr.  */
 
 DEBUG_FUNCTION void
-region_model2::debug () const
+region_model::debug () const
 {
   dump (true);
 }
@@ -4843,10 +3861,10 @@ dump_vec_of_tree (pretty_printer *pp,
 }
 
 /* Dump all *REP_PATH_VARS to PP in compact form, updating *IS_FIRST.
-   Subroutine of region_model2::dump_to_pp.  */
+   Subroutine of region_model::dump_to_pp.  */
 
 void
-region_model2::dump_summary_of_rep_path_vars (pretty_printer *pp,
+region_model::dump_summary_of_rep_path_vars (pretty_printer *pp,
 					     auto_vec<path_var> *rep_path_vars,
 					     bool *is_first)
 {
@@ -4860,26 +3878,26 @@ region_model2::dump_summary_of_rep_path_vars (pretty_printer *pp,
     {
       if (TREE_CODE (pv->m_tree) == STRING_CST)
 	continue;
-      tentative_region_model2_context ctxt;
-      region2_id child_reg = get_lvalue (*pv, &ctxt);
+      tentative_region_model_context ctxt;
+      region_id child_reg = get_lvalue (*pv, &ctxt);
       if (ctxt.had_errors_p ())
 	continue;
-      region2 *child_region2 = get_region2 (child_reg);
-      if (!child_region2)
+      region *child_region = get_region (child_reg);
+      if (!child_region)
 	continue;
-      const svalue2 *sval = child_region2->get_value_direct ();
+      const svalue *sval = child_region->get_value_direct ();
       if (sid.null_p ())
 	continue;
-      const svalue2 *sval = get_svalue2 (sid);
+      const svalue *sval = get_svalue (sid);
       switch (sval->get_kind ())
 	{
 	default:
 	  gcc_unreachable ();
-	case SK_REGION2:
+	case SK_REGION:
 	  {
-	    const region_svalue2 *region2_sval
-	      = as_a <const region_svalue2 *> (sval);
-	    region2_id pointee_reg = region2_sval->get_pointee ();
+	    const region_svalue *region_sval
+	      = as_a <const region_svalue *> (sval);
+	    region_id pointee_reg = region_sval->get_pointee ();
 	    gcc_assert (!pointee_reg.null_p ());
 	    tree pointee = get_representative_path_var (pointee_reg).m_tree;
 	    dump_separator (pp, is_first);
@@ -4896,15 +3914,15 @@ region_model2::dump_summary_of_rep_path_vars (pretty_printer *pp,
 	  dump_separator (pp, is_first);
 	  dump_tree (pp, pv->m_tree);
 	  pp_string (pp, ": ");
-	  dump_tree (pp, sval->dyn_cast_constant_svalue2 ()->get_constant ());
+	  dump_tree (pp, sval->dyn_cast_constant_svalue ()->get_constant ());
 	  break;
 	case SK_UNKNOWN:
 	  unknown_trees.safe_push (pv->m_tree);
 	  break;
 	case SK_POISONED:
 	  {
-	    const poisoned_svalue2 *poisoned_sval
-	      = as_a <const poisoned_svalue2 *> (sval);
+	    const poisoned_svalue *poisoned_sval
+	      = as_a <const poisoned_svalue *> (sval);
 	    enum poison_kind pkind = poisoned_sval->get_poison_kind ();
 	    if (pkind == POISON_KIND_UNINIT)
 	      uninit_trees.safe_push (pv->m_tree);
@@ -4919,7 +3937,7 @@ region_model2::dump_summary_of_rep_path_vars (pretty_printer *pp,
 	case SK_SETJMP:
 	  dump_separator (pp, is_first);
 	  pp_printf (pp, "setjmp: EN: %i",
-		     sval->dyn_cast_setjmp_svalue2 ()->get_enode_index ());
+		     sval->dyn_cast_setjmp_svalue ()->get_enode_index ());
 	  break;
 	}
     }
@@ -4935,7 +3953,7 @@ region_model2::dump_summary_of_rep_path_vars (pretty_printer *pp,
 /* Assert that this object is valid.  */
 
 void
-region_model2::validate () const
+region_model::validate () const
 {
   /* Skip this in a release build.  */
 #if !CHECKING_P
@@ -4945,20 +3963,20 @@ region_model2::validate () const
   m_constraints->validate ();
 
   unsigned i;
-  region2 *r;
-  FOR_EACH_VEC_ELT (m_region2s, i, r)
+  region *r;
+  FOR_EACH_VEC_ELT (m_regions, i, r)
     r->validate (*this);
 
   // TODO: anything else?
 
-  /* Verify that the stack region2 (if any) has an "uninitialized" value.  */
-  region2 *stack_region2 = get_root_region2 ()->get_stack_region2 (this);
-  if (stack_region2)
+  /* Verify that the stack region (if any) has an "uninitialized" value.  */
+  region *stack_region = get_root_region ()->get_stack_region (this);
+  if (stack_region)
     {
-      svalue2_id stack_value_sval = stack_region2->get_value_direct ();
-      const svalue2 *stack_value = get_svalue2 (stack_value_sval);
+      svalue_id stack_value_sval = stack_region->get_value_direct ();
+      const svalue *stack_value = get_svalue (stack_value_sval);
       gcc_assert (stack_value->get_kind () == SK_POISONED);
-      poisoned_svalue2 *subclass = stack_value->dyn_cast_poisoned_svalue2 ();
+      poisoned_svalue *subclass = stack_value->dyn_cast_poisoned_svalue ();
       gcc_assert (subclass);
       gcc_assert (subclass->get_poison_kind () == POISON_KIND_UNINIT);
     }
@@ -4969,18 +3987,18 @@ region_model2::validate () const
 /* FIXME.  */
 
 void
-region_model2::canonicalize ()
+region_model::canonicalize ()
 {
   m_store.canonicalize (m_mgr->get_store_manager ());
-  m_constraints2->canonicalize ();
+  m_constraints->canonicalize ();
 }
 
 /* FIXME.  */
 
 bool
-region_model2::canonicalized_p () const
+region_model::canonicalized_p () const
 {
-  region_model2 copy (*this);
+  region_model copy (*this);
   copy.canonicalize ();
   return *this == copy;
 }
@@ -4988,7 +4006,7 @@ region_model2::canonicalized_p () const
 /* FIXME.  */
 
 void
-region_model2::loop_replay_hack (const region_model2 *dst_state)
+region_model::loop_replay_hack (const region_model *dst_state)
 {
   m_store.loop_replay_hack (dst_state->get_store (), m_mgr);
 }
@@ -4996,8 +4014,8 @@ region_model2::loop_replay_hack (const region_model2 *dst_state)
 /* FIXME.  */
 
 bool
-region_model2::on_stmt (const gimple *stmt,
-			region_model2_context *ctxt)
+region_model::on_stmt (const gimple *stmt,
+			region_model_context *ctxt)
 {
   switch (stmt->code)
     {
@@ -5012,7 +4030,7 @@ region_model2::on_stmt (const gimple *stmt,
 
     case GIMPLE_GOTO:
       /* TODO: GIMPLE_GOTO needs to be handled by the engine, not the
-	 region_model2, but I don't think this is a regression relative to
+	 region_model, but I don't think this is a regression relative to
 	 the old implementation.  */
     case GIMPLE_SWITCH:
     case GIMPLE_LABEL:
@@ -5037,9 +4055,9 @@ region_model2::on_stmt (const gimple *stmt,
    for some SVALUE, get the SVALUE.
    Otherwise return NULL.  */
 
-const svalue2 *
-region_model2::get_gassign_result (const gassign *assign,
-				   region_model2_context *ctxt)
+const svalue *
+region_model::get_gassign_result (const gassign *assign,
+				   region_model_context *ctxt)
 {
   tree lhs = gimple_assign_lhs (assign);
   tree rhs1 = gimple_assign_rhs1 (assign);
@@ -5055,13 +4073,13 @@ region_model2::get_gassign_result (const gassign *assign,
 	tree ptr = rhs1;
 	tree offset = gimple_assign_rhs2 (assign);
 
-	const svalue2 *ptr_sval = get_rvalue (ptr, ctxt);
-	const svalue2 *offset_sval = get_rvalue (offset, ctxt);
+	const svalue *ptr_sval = get_rvalue (ptr, ctxt);
+	const svalue *offset_sval = get_rvalue (offset, ctxt);
 	/* Quoting tree.def, "the second operand [of a POINTER_PLUS_EXPR]
 	   is an integer of type sizetype".  */
 	offset_sval = m_mgr->get_or_create_cast (size_type_node, offset_sval);
 
-	const svalue2 *sval_binop
+	const svalue *sval_binop
 	  = m_mgr->get_or_create_binop (TREE_TYPE (lhs), op,
 					ptr_sval, offset_sval);
 	return sval_binop;
@@ -5072,12 +4090,12 @@ region_model2::get_gassign_result (const gassign *assign,
       {
 	/* e.g. "_1 = p_2(D) - q_3(D);".  */
 	tree rhs2 = gimple_assign_rhs2 (assign);
-	const svalue2 *rhs1_sval = get_rvalue (rhs1, ctxt);
-	const svalue2 *rhs2_sval = get_rvalue (rhs2, ctxt);
+	const svalue *rhs1_sval = get_rvalue (rhs1, ctxt);
+	const svalue *rhs2_sval = get_rvalue (rhs2, ctxt);
 
 	// TODO: perhaps fold to zero if they're known to be equal?
 
-	const svalue2 *sval_binop
+	const svalue *sval_binop
 	  = m_mgr->get_or_create_binop (TREE_TYPE (lhs), op,
 					rhs1_sval, rhs2_sval);
 	return sval_binop;
@@ -5115,8 +4133,8 @@ region_model2::get_gassign_result (const gassign *assign,
     case VIEW_CONVERT_EXPR:
       {
 	/* Unary ops.  */
-	const svalue2 *rhs_sval = get_rvalue (rhs1, ctxt);
-	const svalue2 *sval_unaryop
+	const svalue *rhs_sval = get_rvalue (rhs1, ctxt);
+	const svalue *sval_unaryop
 	  = m_mgr->get_or_create_unaryop (TREE_TYPE (lhs), op, rhs_sval);
 	return sval_unaryop;
       }
@@ -5132,9 +4150,9 @@ region_model2::get_gassign_result (const gassign *assign,
       {
 	tree rhs2 = gimple_assign_rhs2 (assign);
 
-	// TODO: constraints between svalue2s
-	const svalue2 *rhs1_sval = get_rvalue (rhs1, ctxt);
-	const svalue2 *rhs2_sval = get_rvalue (rhs2, ctxt);
+	// TODO: constraints between svalues
+	const svalue *rhs1_sval = get_rvalue (rhs1, ctxt);
+	const svalue *rhs2_sval = get_rvalue (rhs2, ctxt);
 
 	tristate t = eval_condition (rhs1_sval, op, rhs2_sval);
 	if (t.is_known ())
@@ -5145,7 +4163,7 @@ region_model2::get_gassign_result (const gassign *assign,
 	else
 	  {
 	    // TODO: symbolic value for binop
-	    const svalue2 *sval_binop
+	    const svalue *sval_binop
 	      = m_mgr->get_or_create_binop (TREE_TYPE (lhs), op,
 					    rhs1_sval, rhs2_sval);
 	    return sval_binop;
@@ -5181,10 +4199,10 @@ region_model2::get_gassign_result (const gassign *assign,
 	/* Binary ops.  */
 	tree rhs2 = gimple_assign_rhs2 (assign);
 
-	const svalue2 *rhs1_sval = get_rvalue (rhs1, ctxt);
-	const svalue2 *rhs2_sval = get_rvalue (rhs2, ctxt);
+	const svalue *rhs1_sval = get_rvalue (rhs1, ctxt);
+	const svalue *rhs2_sval = get_rvalue (rhs2, ctxt);
 
-	const svalue2 *sval_binop
+	const svalue *sval_binop
 	  = m_mgr->get_or_create_binop (TREE_TYPE (lhs), op,
 					rhs1_sval, rhs2_sval);
 	return sval_binop;
@@ -5196,7 +4214,7 @@ region_model2::get_gassign_result (const gassign *assign,
     case VEC_SERIES_EXPR:
     case VEC_COND_EXPR:
     case VEC_PERM_EXPR:
-      return m_mgr->get_or_create_unknown_svalue2 (TREE_TYPE (lhs));
+      return m_mgr->get_or_create_unknown_svalue (TREE_TYPE (lhs));
     }
 }
 
@@ -5205,18 +4223,18 @@ region_model2::get_gassign_result (const gassign *assign,
    diagnostics.  */
 
 bool
-region_model2::on_gassign (const gassign *assign,
-			   region_model2_context *ctxt)
+region_model::on_gassign (const gassign *assign,
+			   region_model_context *ctxt)
 {
   tree lhs = gimple_assign_lhs (assign);
   tree rhs1 = gimple_assign_rhs1 (assign);
 
-  const region2 *lhs_reg = get_lvalue (lhs, ctxt);
+  const region *lhs_reg = get_lvalue (lhs, ctxt);
 
   /* Most assignments are handled by:
        set_value (lhs_reg, SVALUE, CTXT)
      for some SVALUE.  */
-  if (const svalue2 *sval = get_gassign_result (assign, ctxt))
+  if (const svalue *sval = get_gassign_result (assign, ctxt))
     {
       set_value (lhs_reg, sval, ctxt);
       return true;
@@ -5260,14 +4278,14 @@ region_model2::on_gassign (const gassign *assign,
 		if (!index)
 		  index = build_int_cst (integer_type_node, ix);
 		gcc_assert (TREE_CODE (index) == INTEGER_CST);
-		const svalue2 *index_sval
-		  = m_mgr->get_or_create_constant_svalue2 (index);
+		const svalue *index_sval
+		  = m_mgr->get_or_create_constant_svalue (index);
 		gcc_assert (index_sval);
-		const region2 *sub_reg
+		const region *sub_reg
 		  = m_mgr->get_element_region (lhs_reg,
 					       TREE_TYPE (val),
 					       index_sval);
-		const svalue2 *val_sval = get_rvalue (val, ctxt);
+		const svalue *val_sval = get_rvalue (val, ctxt);
 		set_value (sub_reg, val_sval, ctxt);
 	      }
 	  }
@@ -5279,7 +4297,7 @@ region_model2::on_gassign (const gassign *assign,
 	/* e.g. "struct s2 x = {{'A', 'B', 'C', 'D'}};".  */
 	/* 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);
+	const svalue *rhs_sval = get_rvalue (rhs1, ctxt);
 	m_store.set_value (m_mgr->get_store_manager(), lhs_reg, rhs_sval,
 			   BK_default);
       }
@@ -5292,10 +4310,10 @@ region_model2::on_gassign (const gassign *assign,
 /* FIXME.  */
 #if 0
 bool
-region_model2::on_gcall (const supernode *snode,
+region_model::on_gcall (const supernode *snode,
 			 const gcall *call)
 {
-  region_model2_context *ctxt = NULL; // FIXME
+  region_model_context *ctxt = NULL; // FIXME
 
   bool unknown_effects = false;
 
@@ -5326,7 +4344,7 @@ region_model2::on_gcall (const supernode *snode,
   if (tree callee_fndecl = get_fndecl_for_call (call, ctxt))
     {
       /* Get any left-hand side for the destination of the result.  */
-      region2 *lhs_reg = NULL;
+      region *lhs_reg = NULL;
       tree lhs_type = NULL_TREE;
       if (tree lhs = gimple_call_lhs (call))
 	{
@@ -5337,11 +4355,11 @@ region_model2::on_gcall (const supernode *snode,
       if (is_named_call_p (callee_fndecl, "malloc", call, 1))
 	{
 	  tree size_arg = gimple_call_arg (call, 0);
-	  const svalue2 *size_sval = get_rvalue (size_arg, ctxt);
-	  region2 *new_reg = create_region_for_heap_alloc (size_sval);
+	  const svalue *size_sval = get_rvalue (size_arg, ctxt);
+	  region *new_reg = create_region_for_heap_alloc (size_sval);
 	  if (lhs_reg)
 	    {
-	      const svalue2 *ptr_sval = m_mgr->get_ptr_svalue2 (lhs_type, new_reg);
+	      const svalue *ptr_sval = m_mgr->get_ptr_svalue (lhs_type, new_reg);
 	      set_value (lhs_reg, ptr_sval, ctxt);
 	    }
 	  else
@@ -5353,11 +4371,11 @@ region_model2::on_gcall (const supernode *snode,
       else if (is_named_call_p (callee_fndecl, "__builtin_alloca", call, 1))
 	{
 	  tree size_arg = gimple_call_arg (call, 0);
-	  const svalue2 *size_sval = get_rvalue (size_arg, ctxt);
-	  region2 *new_reg = create_region_for_alloca (size_sval);
+	  const svalue *size_sval = get_rvalue (size_arg, ctxt);
+	  region *new_reg = create_region_for_alloca (size_sval);
 	  if (lhs_reg)
 	    {
-	      const svalue2 *ptr_sval = m_mgr->get_ptr_svalue2 (lhs_type, new_reg);
+	      const svalue *ptr_sval = m_mgr->get_ptr_svalue (lhs_type, new_reg);
 	      set_value (lhs_reg, ptr_sval, ctxt);
 	    }
 	  return true;
@@ -5365,17 +4383,17 @@ region_model2::on_gcall (const supernode *snode,
       else if (is_named_call_p (callee_fndecl, "strlen", call, 1))
 	{
 	  tree arg = gimple_call_arg (call, 0);
-	  const svalue2 *arg_sval = get_rvalue (arg, ctxt);
-	  region2 *buf_reg = deref_rvalue (arg_sval, ctxt);
-	  if (string_region2 *str_reg = buf_reg->dyn_cast_string_region2 ())
+	  const svalue *arg_sval = get_rvalue (arg, ctxt);
+	  region *buf_reg = deref_rvalue (arg_sval, ctxt);
+	  if (string_region *str_reg = buf_reg->dyn_cast_string_region ())
 	    {
 	      tree str_cst = str_reg->get_string_cst ();
 	      /* TREE_STRING_LENGTH is sizeof, not strlen.  */
 	      int sizeof_cst = TREE_STRING_LENGTH (str_cst);
 	      int strlen_cst = sizeof_cst - 1;
 	      tree t_cst = build_int_cst (lhs_type, strlen_cst);
-	      const svalue2 *result_sval
-		= m_mgr->get_or_create_constant_svalue2 (t_cst);
+	      const svalue *result_sval
+		= m_mgr->get_or_create_constant_svalue (t_cst);
 	      set_value (lhs_reg, result_sval, ctxt);
 	      return true;
 	    }
@@ -5400,17 +4418,17 @@ region_model2::on_gcall (const supernode *snode,
 /* A subclass of pending_diagnostic for complaining about uses of
    poisoned values.  */
 
-class poisoned_value_diagnostic2
-: public pending_diagnostic_subclass<poisoned_value_diagnostic2>
+class poisoned_value_diagnostic
+: public pending_diagnostic_subclass<poisoned_value_diagnostic>
 {
 public:
-  poisoned_value_diagnostic2 (tree expr, enum poison_kind pkind)
+  poisoned_value_diagnostic (tree expr, enum poison_kind pkind)
   : m_expr (expr), m_pkind (pkind)
   {}
 
-  const char *get_kind () const FINAL OVERRIDE { return "poisoned_value_diagnostic2"; }
+  const char *get_kind () const FINAL OVERRIDE { return "poisoned_value_diagnostic"; }
 
-  bool operator== (const poisoned_value_diagnostic2 &other) const
+  bool operator== (const poisoned_value_diagnostic &other) const
   {
     return m_expr == other.m_expr;
   }
@@ -5468,16 +4486,16 @@ private:
 /* Update this model for the CALL stmt, using CTXT to report any
    diagnostics - the first half.
 
-   Updates to the region_model2 that should be made *before* sm-states
-   are updated are done here; other updates to the region_model2 are done
-   in region_model2::on_call_post.
+   Updates to the region_model that should be made *before* sm-states
+   are updated are done here; other updates to the region_model are done
+   in region_model::on_call_post.
 
    Return true if the function call has unknown side effects (it wasn't
    recognized and we don't have a body for it, or are unable to tell which
    fndecl it is).  */
 
 bool
-region_model2::on_call_pre (const gcall *call, region_model2_context *ctxt)
+region_model::on_call_pre (const gcall *call, region_model_context *ctxt)
 {
   /* Check for uses of poisoned values.
      For now, special-case "free", to avoid warning about "use-after-free"
@@ -5495,7 +4513,7 @@ region_model2::on_call_pre (const gcall *call, region_model2_context *ctxt)
       call_details cd (call, this, ctxt);
 
       /* The various impl_call_* member functions are implemented
-	 in region-model2-impl-calls.cc.
+	 in region-model-impl-calls.cc.
 	 Having them split out into separate functions makes it easier
 	 to put breakpoints on the handling of specific functions.  */
 
@@ -5536,11 +4554,11 @@ region_model2::on_call_pre (const gcall *call, region_model2_context *ctxt)
      now.  */
   if (tree lhs = gimple_call_lhs (call))
     {
-      const region2 *lhs_region = get_lvalue (lhs, ctxt);
+      const region *lhs_region = get_lvalue (lhs, ctxt);
       // FIXME
       if (TREE_CODE (lhs) == SSA_NAME)
 	{
-	  const svalue2 *sval = m_mgr->get_or_create_initial_value (lhs_region);
+	  const svalue *sval = m_mgr->get_or_create_initial_value (lhs_region);
 	  set_value (lhs_region, sval, ctxt);
 	}
     }
@@ -5556,17 +4574,17 @@ region_model2::on_call_pre (const gcall *call, region_model2_context *ctxt)
 /* Update this model for the CALL stmt, using CTXT to report any
    diagnostics - the second half.
 
-   Updates to the region_model2 that should be made *after* sm-states
-   are updated are done here; other updates to the region_model2 are done
-   in region_model2::on_call_pre.
+   Updates to the region_model that should be made *after* sm-states
+   are updated are done here; other updates to the region_model are done
+   in region_model::on_call_pre.
 
    If UNKNOWN_SIDE_EFFECTS is true, also call handle_unrecognized_call
    to purge state.  */
 
 void
-region_model2::on_call_post (const gcall *call,
+region_model::on_call_post (const gcall *call,
 			     bool unknown_side_effects,
-			     region_model2_context *ctxt)
+			     region_model_context *ctxt)
 {
   if (tree callee_fndecl = get_fndecl_for_call (call, ctxt))
     if (is_named_call_p (callee_fndecl, "free", call, 1))
@@ -5582,25 +4600,25 @@ region_model2::on_call_post (const gcall *call,
 
 /* Handle a call CALL to a function with unknown behavior.
 
-   Traverse the region2s in this model, determining what region2s are
+   Traverse the regions in this model, determining what regions are
    reachable from pointer arguments to CALL and from global variables,
    recursively.
 
-   Set all reachable region2s to new unknown values and purge sm-state
+   Set all reachable regions to new unknown values and purge sm-state
    from their values, and from values that point to them.  */
 void
-region_model2::handle_unrecognized_call (const gcall *call,
-					 region_model2_context *ctxt)
+region_model::handle_unrecognized_call (const gcall *call,
+					 region_model_context *ctxt)
 {
   tree fndecl = get_fndecl_for_call (call, ctxt);
 
-  reachable_region2s reachable_regs (&m_store, m_mgr);
+  reachable_regions reachable_regs (&m_store, m_mgr);
 
-  /* Determine the reachable region2s and their mutability.  */
+  /* Determine the reachable regions and their mutability.  */
   {
     /* Add globals and regions that already escaped in previous
        unknown calls.  */
-    m_store.for_each_cluster (reachable_region2s::init_cluster_cb,
+    m_store.for_each_cluster (reachable_regions::init_cluster_cb,
 			      &reachable_regs);
 
     /* Params that are pointers.  */
@@ -5619,7 +4637,7 @@ region_model2::handle_unrecognized_call (const gcall *call,
 	  }
 
 	tree parm = gimple_call_arg (call, arg_idx);
-	const svalue2 *parm_sval = get_rvalue (parm, ctxt);
+	const svalue *parm_sval = get_rvalue (parm, ctxt);
 	reachable_regs.handle_parm (parm_sval, param_type);
 	// FIXME: what about compound parms that contain ptrs?
       }
@@ -5627,18 +4645,18 @@ region_model2::handle_unrecognized_call (const gcall *call,
 
   /* Purge sm-state for the svalues that were reachable,
      both in non-mutable and mutable form.  */
-  for (hash_set<const svalue2 *>::iterator iter
+  for (hash_set<const svalue *>::iterator iter
 	 = reachable_regs.begin_reachable_svals ();
        iter != reachable_regs.end_reachable_svals (); ++iter)
     {
-      const svalue2 *sval = (*iter);
+      const svalue *sval = (*iter);
       ctxt->on_unknown_change (sval, false);
     }
-  for (hash_set<const svalue2 *>::iterator iter
+  for (hash_set<const svalue *>::iterator iter
 	 = reachable_regs.begin_mutable_svals ();
        iter != reachable_regs.end_mutable_svals (); ++iter)
     {
-      const svalue2 *sval = (*iter);
+      const svalue *sval = (*iter);
       ctxt->on_unknown_change (sval, true);
     }
 
@@ -5650,22 +4668,22 @@ region_model2::handle_unrecognized_call (const gcall *call,
   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
+  /* Purge sm-state for any remaining svalues that point to regions that
      were reachable.  This helps suppress leak false-positives.
 
      For example, if we had a malloc call that was cast to a "foo *" type,
      we could have a temporary void * for the result of malloc which has its
-     own svalue2, not reachable from the function call, but for which the
-     "foo *" svalue2 was reachable.  If we don't purge it, the temporary will
+     own svalue, not reachable from the function call, but for which the
+     "foo *" svalue was reachable.  If we don't purge it, the temporary will
      be reported as a leak.  */
   int i;
-  const svalue2 *svalue2;
-  FOR_EACH_VEC_ELT (m_svalue2s, i, svalue2)
-    if (region_const svalue2 *ptr = svalue2->dyn_cast_region_svalue2 ())
+  const svalue *svalue;
+  FOR_EACH_VEC_ELT (m_svalues, i, svalue)
+    if (region_const svalue *ptr = svalue->dyn_cast_region_svalue ())
       {
-	region2 *pointee_reg = ptr->get_pointee ();
-	if (reachable_region2s.mutable_p (pointee_reg))
-	  ctxt->on_unknown_change (svalue2_id::from_int (i));
+	region *pointee_reg = ptr->get_pointee ();
+	if (reachable_regions.mutable_p (pointee_reg))
+	  ctxt->on_unknown_change (svalue_id::from_int (i));
       }
 
   validate ();
@@ -5675,13 +4693,13 @@ region_model2::handle_unrecognized_call (const gcall *call,
 /* FIXME.  */
 
 static void
-add_svalues_to_set_cb (const svalue2 *sval, hash_set<const svalue2 *> *out)
+add_svalues_to_set_cb (const svalue *sval, hash_set<const svalue *> *out)
 {
   out->add (sval);
 }
 
 /* FIXME.
-   Traverse the region2s in this model, determining what region2s are
+   Traverse the regions in this model, determining what regions are
    reachable from the store.
 
    If EXTRA_SVAL is non-NULL, treat it as an additional "root"
@@ -5691,14 +4709,14 @@ add_svalues_to_set_cb (const svalue2 *sval, hash_set<const svalue2 *> *out)
    Find svalues that haven't leaked.    */
 
 void
-region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
-				      const svalue2 *extra_sval)
+region_model::get_reachable_svalues (hash_set<const svalue *> *out,
+				      const svalue *extra_sval)
 {
-  reachable_region2s reachable_regs (&m_store, m_mgr);
+  reachable_regions reachable_regs (&m_store, m_mgr);
 
   /* Add globals and regions that already escaped in previous
      unknown calls.  */
-  m_store.for_each_cluster (reachable_region2s::init_cluster_cb,
+  m_store.for_each_cluster (reachable_regions::init_cluster_cb,
 			    &reachable_regs);
 
   if (extra_sval)
@@ -5706,10 +4724,10 @@ region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
 
 #if 0
   /* Mark all locals in all frames (and what's reachable from them).  */
-  for (const frame_region2 *iter_frame = get_current_frame ();
+  for (const frame_region *iter_frame = get_current_frame ();
        iter_frame; iter_frame = iter_frame->get_calling_frame ())
     {
-      region_model2_context *ctxt = NULL; // FIXME
+      region_model_context *ctxt = NULL; // FIXME
       unsigned i;
       tree name;
       FOR_EACH_SSA_NAME (i, name, iter_frame->get_function ())
@@ -5719,7 +4737,7 @@ region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
 	    if (TREE_CODE (var) == VAR_DECL)
 	      if (VAR_DECL_IS_VIRTUAL_OPERAND (var))
 		continue;
-	  const region2 *name_reg
+	  const region *name_reg
 	    = iter_frame->get_region_for_local (m_mgr, name, ctxt);
 	  reachable_regs.add (name_reg, false);
 	}
@@ -5735,9 +4753,9 @@ region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
   for (store::cluster_map_t::iterator iter = m_store.begin ();
        iter != m_store.end (); ++iter)
     {
-      const region2 *base_reg = (*iter).first;
-      if (const region2 *parent = base_reg->get_parent_region ())
-	if (parent->get_kind () == region2::RK_FRAME)
+      const region *base_reg = (*iter).first;
+      if (const region *parent = base_reg->get_parent_region ())
+	if (parent->get_kind () == region::RK_FRAME)
 	  reachable_regs.add (base_reg, false);
     }
   /* TODO: we also need to count the regions for live SSA names
@@ -5747,7 +4765,7 @@ region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
 
 #if 1
   /* Populate *OUT based on the values that were reachable.  */
-  for (hash_set<const svalue2 *>::iterator iter
+  for (hash_set<const svalue *>::iterator iter
 	 = reachable_regs.begin_reachable_svals ();
        iter != reachable_regs.end_reachable_svals (); ++iter)
     {
@@ -5755,18 +4773,18 @@ region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
     }
 #else
   /* Populate *OUT based on the clusters that were reachable.  */
-  for (hash_set<const region2 *>::iterator iter = reachable_regs.begin ();
+  for (hash_set<const region *>::iterator iter = reachable_regs.begin ();
        iter != reachable_regs.end (); ++iter)
     {
-      const region2 *base_reg = (*iter);
-      binding_cluster2 *cluster = m_store.get_cluster (base_reg);
+      const region *base_reg = (*iter);
+      binding_cluster *cluster = m_store.get_cluster (base_reg);
       if (cluster)
 	cluster->for_each_value (add_svalues_to_set_cb, out);
       else
 	{
 	  /* If not explicitly bound (or escaped), add initial svalue.
 	     FIXME: what about uninit?  */
-	  const svalue2 *init = m_mgr->get_or_create_initial_value (base_reg);
+	  const svalue *init = m_mgr->get_or_create_initial_value (base_reg);
 	  out->add (init);
 	}
     }
@@ -5777,8 +4795,8 @@ region_model2::get_reachable_svalues (hash_set<const svalue2 *> *out,
    diagnostics.  */
 
 bool
-region_model2::on_greturn (const greturn *return_stmt,
-			   region_model2_context *ctxt)
+region_model::on_greturn (const greturn *return_stmt,
+			   region_model_context *ctxt)
 {
   tree callee = get_current_function ()->decl;
   tree lhs = DECL_RESULT (callee);
@@ -5798,20 +4816,20 @@ region_model2::on_greturn (const greturn *return_stmt,
    0), as opposed to any second return due to longjmp/sigsetjmp.  */
 
 void
-region_model2::on_setjmp (const gcall *call, const exploded_node *enode,
-			 region_model2_context *ctxt)
+region_model::on_setjmp (const gcall *call, const exploded_node *enode,
+			 region_model_context *ctxt)
 {
-  const svalue2 *buf_ptr = get_rvalue (gimple_call_arg (call, 0), ctxt);
-  const region2 *buf_reg = deref_rvalue (buf_ptr, gimple_call_arg (call, 0),
+  const svalue *buf_ptr = get_rvalue (gimple_call_arg (call, 0), ctxt);
+  const region *buf_reg = deref_rvalue (buf_ptr, gimple_call_arg (call, 0),
 					 ctxt);
 
-  /* Create a setjmp_svalue2 for this call and store it in BUF_REG's
-     region2.  */
+  /* Create a setjmp_svalue for this call and store it in BUF_REG's
+     region.  */
   if (buf_reg)
     {
       setjmp_record r (enode, call);
-      const svalue2 *sval
-	= m_mgr->get_or_create_setjmp_svalue2 (r, buf_reg->get_type ());
+      const svalue *sval
+	= m_mgr->get_or_create_setjmp_svalue (r, buf_reg->get_type ());
       set_value (buf_reg, sval, ctxt);
     }
 
@@ -5819,31 +4837,31 @@ region_model2::on_setjmp (const gcall *call, const exploded_node *enode,
   if (tree lhs = gimple_call_lhs (call))
     {
       tree zero = build_int_cst (TREE_TYPE (lhs), 0);
-      const svalue2 *new_sval = m_mgr->get_or_create_constant_svalue2 (zero);
-      const region2 *lhs_reg = get_lvalue (lhs, ctxt);
+      const svalue *new_sval = m_mgr->get_or_create_constant_svalue (zero);
+      const region *lhs_reg = get_lvalue (lhs, ctxt);
       set_value (lhs_reg, new_sval, ctxt);
     }
 }
 
-/* Update this region_model2 for rewinding from a "longjmp" at LONGJMP_CALL
+/* Update this region_model for rewinding from a "longjmp" at LONGJMP_CALL
    to a "setjmp" at SETJMP_CALL where the final stack depth should be
    SETJMP_STACK_DEPTH.  Pop any stack frames.  Leak detection is *not*
    done, and should be done by the caller.  */
 
 void
-region_model2::on_longjmp (const gcall *longjmp_call, const gcall *setjmp_call,
-			   int setjmp_stack_depth, region_model2_context *ctxt)
+region_model::on_longjmp (const gcall *longjmp_call, const gcall *setjmp_call,
+			   int setjmp_stack_depth, region_model_context *ctxt)
 {
   /* Evaluate the val, using the frame of the "longjmp".  */
   tree fake_retval = gimple_call_arg (longjmp_call, 1);
-  const svalue2 *fake_retval_sval = get_rvalue (fake_retval, ctxt);
+  const svalue *fake_retval_sval = get_rvalue (fake_retval, ctxt);
 
   /* Pop any frames until we reach the stack depth of the function where
      setjmp was called.  */
   gcc_assert (get_stack_depth () >= setjmp_stack_depth);
   while (get_stack_depth () > setjmp_stack_depth)
     {
-      /* Don't purge unused svalue2s yet, as we're using fake_retval_sval.  */
+      /* Don't purge unused svalues yet, as we're using fake_retval_sval.  */
       pop_frame (NULL, false, NULL, NULL, ctxt);
     }
 
@@ -5854,20 +4872,20 @@ region_model2::on_longjmp (const gcall *longjmp_call, const gcall *setjmp_call,
     {
       /* Passing 0 as the val to longjmp leads to setjmp returning 1.  */
       tree t_zero = build_int_cst (TREE_TYPE (fake_retval), 0);
-      const svalue2 *zero_sval = m_mgr->get_or_create_constant_svalue2 (t_zero);
+      const svalue *zero_sval = m_mgr->get_or_create_constant_svalue (t_zero);
       tristate eq_zero = eval_condition (fake_retval_sval, EQ_EXPR, zero_sval);
       /* If we have 0, use 1.  */
       if (eq_zero.is_true ())
 	{
 	  tree t_one = build_int_cst (TREE_TYPE (fake_retval), 1);
-	  const svalue2 *one_sval
-	    = m_mgr->get_or_create_constant_svalue2 (t_one);
+	  const svalue *one_sval
+	    = m_mgr->get_or_create_constant_svalue (t_one);
 	  fake_retval_sval = one_sval;
 	}
       else
 	{
 	  /* Otherwise note that the value is nonzero.  */
-	  m_constraints2->add_constraint (fake_retval_sval, NE_EXPR, zero_sval);
+	  m_constraints->add_constraint (fake_retval_sval, NE_EXPR, zero_sval);
 	}
 
       /* Decorate the return value from setjmp as being unmergeable,
@@ -5877,19 +4895,19 @@ region_model2::on_longjmp (const gcall *longjmp_call, const gcall *setjmp_call,
 	 return.  */
       fake_retval_sval = m_mgr->get_or_create_unmergeable (fake_retval_sval);
 
-      const region2 *lhs_reg = get_lvalue (lhs, ctxt);
+      const region *lhs_reg = get_lvalue (lhs, ctxt);
       set_value (lhs_reg, fake_retval_sval, ctxt);
     }
 }
 
-/* Update this region_model2 for a phi stmt of the form
+/* Update this region_model for a phi stmt of the form
      LHS = PHI <...RHS...>.
    where RHS is for the appropriate edge.  */
 
 void
-region_model2::handle_phi (const gphi *phi,
+region_model::handle_phi (const gphi *phi,
 			   tree lhs, tree rhs, bool is_back_edge,
-			   region_model2_context *ctxt)
+			   region_model_context *ctxt)
 {
   /* For now, don't bother tracking the .MEM SSA names.  */
   if (tree var = SSA_NAME_VAR (lhs))
@@ -5897,12 +4915,12 @@ region_model2::handle_phi (const gphi *phi,
       if (VAR_DECL_IS_VIRTUAL_OPERAND (var))
 	return;
 
-  const svalue2 *rhs_sval = get_rvalue (rhs, ctxt);
+  const svalue *rhs_sval = get_rvalue (rhs, ctxt);
 
-  /* FIXME: WIP on replacing this with widening_svalue2, which ought
+  /* FIXME: WIP on replacing this with widening_svalue, which ought
      to be a more general solution.  */
 #if !WIDENING
-  if (is_back_edge && rhs_sval->get_kind () != svalue2::SK_UNKNOWN)
+  if (is_back_edge && rhs_sval->get_kind () != svalue::SK_UNKNOWN)
     {
       //FIXME:
       /* If we have a back edge, we probably have a loop.
@@ -5910,9 +4928,9 @@ region_model2::handle_phi (const gphi *phi,
 	 loop.
 	 To terminate, we need to avoid generating a series of
 	 models with an unbounded monotonically increasing number of
-	 redundant unknown values; hence we need to purge svalue2s
+	 redundant unknown values; hence we need to purge svalues
 	 before inserting the state into the exploded graph, to
-	 collect unused svalue2s.  */
+	 collect unused svalues.  */
       mark_region_as_unknown (get_lvalue (lhs, ctxt));
     }
   else
@@ -5923,14 +4941,14 @@ region_model2::handle_phi (const gphi *phi,
     ctxt->on_phi (phi, rhs);
 }
 
-/* Implementation of region_model2::get_lvalue; the latter adds type-checking.
+/* Implementation of region_model::get_lvalue; the latter adds type-checking.
 
-   Get the id of the region2 for PV within this region_model2,
+   Get the id of the region for PV within this region_model,
    emitting any diagnostics to CTXT.  */
 
-const region2 *
-region_model2::get_lvalue_1 (path_var pv,
-			     region_model2_context *ctxt)
+const region *
+region_model::get_lvalue_1 (path_var pv,
+			     region_model_context *ctxt)
 {
   tree expr = pv.m_tree;
 
@@ -5941,7 +4959,7 @@ region_model2::get_lvalue_1 (path_var pv,
     {
     default:
 #if 1
-      return m_mgr->get_region2_for_unexpected_tree_code (ctxt, expr,
+      return m_mgr->get_region_for_unexpected_tree_code (ctxt, expr,
 							  dump_location_t ());
 #else
       gcc_unreachable (); // FIXME
@@ -5957,22 +4975,22 @@ region_model2::get_lvalue_1 (path_var pv,
 	gcc_assert (TREE_OPERAND (expr, 3) == NULL_TREE);
 #endif
 
-	const region2 *array_reg = get_lvalue (array, ctxt);
-	const svalue2 *index_sval = get_rvalue (index, ctxt);
+	const region *array_reg = get_lvalue (array, ctxt);
+	const svalue *index_sval = get_rvalue (index, ctxt);
 	return m_mgr->get_element_region (array_reg,
 					  TREE_TYPE (TREE_TYPE (array)),
 					  index_sval);
 #if 0
-	const region2 *base_array_reg = get_region2 (array_reg);
-	array_region2 *array_reg  = base_array_reg->dyn_cast_array_region2 ();
+	const region *base_array_reg = get_region (array_reg);
+	array_region *array_reg  = base_array_reg->dyn_cast_array_region ();
 	if (!array_reg)
 	  {
-	    /* Normally, array_reg ought to refer to an array_region2, since
+	    /* Normally, array_reg ought to refer to an array_region, since
 	       array's type will be ARRAY_TYPE.  However, if we have an
 	       unexpected tree code for array, we could have a
-	       symbolic_region2 here.  If so, we're in error-handling. */
+	       symbolic_region here.  If so, we're in error-handling. */
 	    gcc_assert (base_array_reg->get_type () == NULL_TREE);
-	    return make_region2_for_unexpected_tree_code (ctxt, expr,
+	    return make_region_for_unexpected_tree_code (ctxt, expr,
 							 dump_location_t ());
 	  }
 	return array_reg->get_element (this, array_reg, index_sval, ctxt);
@@ -5994,9 +5012,9 @@ region_model2::get_lvalue_1 (path_var pv,
       {
 	tree ptr = TREE_OPERAND (expr, 0);
 	tree offset = TREE_OPERAND (expr, 1);
-	const svalue2 *ptr_sval = get_rvalue (ptr, ctxt);
-	const svalue2 *offset_sval = get_rvalue (offset, ctxt);
-	const region2 *star_ptr = deref_rvalue (ptr_sval, ptr, ctxt);
+	const svalue *ptr_sval = get_rvalue (ptr, ctxt);
+	const svalue *offset_sval = get_rvalue (offset, ctxt);
+	const region *star_ptr = deref_rvalue (ptr_sval, ptr, ctxt);
 	return m_mgr->get_offset_region (star_ptr,
 					 TREE_TYPE (expr),
 					 offset_sval);
@@ -6026,7 +5044,7 @@ region_model2::get_lvalue_1 (path_var pv,
 		    || TREE_CODE (expr) == RESULT_DECL);
 
 	int stack_index = pv.m_stack_depth;
-	const frame_region2 *frame = get_frame_at_index (stack_index);
+	const frame_region *frame = get_frame_at_index (stack_index);
 	gcc_assert (frame);
 	return frame->get_region_for_local (m_mgr, expr);
       }
@@ -6041,10 +5059,10 @@ region_model2::get_lvalue_1 (path_var pv,
 #if 0
 	if (TREE_CODE (obj_type) != RECORD_TYPE
 	    && TREE_CODE (obj_type) != UNION_TYPE)
-	  return make_region2_for_unexpected_tree_code (ctxt, obj_type,
+	  return make_region_for_unexpected_tree_code (ctxt, obj_type,
 						       dump_location_t ());
 #endif
-	const region2 *obj_reg = get_lvalue (obj, ctxt);
+	const region *obj_reg = get_lvalue (obj, ctxt);
 	return m_mgr->get_field_region (obj_reg, field);
       }
       break;
@@ -6052,12 +5070,12 @@ region_model2::get_lvalue_1 (path_var pv,
     case CONST_DECL:
       {
 	tree cst_type = TREE_TYPE (expr);
-	const region2 *cst_reg
-	  = add_region2_for_type (m_root_reg, cst_type, ctxt);
+	const region *cst_reg
+	  = add_region_for_type (m_root_reg, cst_type, ctxt);
 	if (tree value = DECL_INITIAL (expr))
 	  {
-	    const svalue2 *sval = get_rvalue (value, ctxt);
-	    get_region2 (cst_reg)->set_value (*this, cst_reg, sid, ctxt);
+	    const svalue *sval = get_rvalue (value, ctxt);
+	    get_region (cst_reg)->set_value (*this, cst_reg, sid, ctxt);
 	  }
 	return cst_reg;
       }
@@ -6090,39 +5108,39 @@ assert_compat_types (tree src_type, tree dst_type)
       internal_error ("incompatible types: %qT and %qT", src_type, dst_type);
 }
 
-/* Get the region2 for PV within this region_model2,
+/* Get the region for PV within this region_model,
    emitting any diagnostics to CTXT.  */
 
-const region2 *
-region_model2::get_lvalue (path_var pv,
-			   region_model2_context *ctxt)
+const region *
+region_model::get_lvalue (path_var pv,
+			   region_model_context *ctxt)
 {
   if (pv.m_tree == NULL_TREE)
     return NULL;
 
-  const region2 *result_reg = get_lvalue_1 (pv, ctxt);
+  const region *result_reg = get_lvalue_1 (pv, ctxt);
   assert_compat_types (result_reg->get_type (), TREE_TYPE (pv.m_tree));
   return result_reg;
 }
 
-/* Get the region2 for EXPR within this region_model2 (assuming the most
+/* Get the region for EXPR within this region_model (assuming the most
    recent stack frame if it's a local).  */
 
-const region2 *
-region_model2::get_lvalue (tree expr,
-			   region_model2_context *ctxt)
+const region *
+region_model::get_lvalue (tree expr,
+			   region_model_context *ctxt)
 {
   return get_lvalue (path_var (expr, get_stack_depth () - 1), ctxt);
 }
 
-/* Implementation of region_model2::get_rvalue; the latter adds type-checking.
+/* Implementation of region_model::get_rvalue; the latter adds type-checking.
 
-   Get the value of PV within this region_model2,
+   Get the value of PV within this region_model,
    emitting any diagnostics to CTXT.  */
 
-const svalue2 *
-region_model2::get_rvalue_1 (path_var pv,
-			     region_model2_context *ctxt)
+const svalue *
+region_model::get_rvalue_1 (path_var pv,
+			     region_model_context *ctxt)
 {
   gcc_assert (pv.m_tree);
 
@@ -6132,8 +5150,8 @@ region_model2::get_rvalue_1 (path_var pv,
       {
 	gcc_unreachable ();
 #if 0
-	const svalue2 *unknown_sval = new unknown_svalue2 (TREE_TYPE (pv.m_tree));
-	return add_svalue2 (unknown_sval);
+	const svalue *unknown_sval = new unknown_svalue (TREE_TYPE (pv.m_tree));
+	return add_svalue (unknown_sval);
 #endif
       }
       break;
@@ -6145,12 +5163,12 @@ region_model2::get_rvalue_1 (path_var pv,
 	tree op0 = TREE_OPERAND (expr, 0);
 #if 0
 	if (TREE_CODE (op0) == FUNCTION_DECL)
-	  return m_mgr->get_svalue2_for_fndecl (TREE_TYPE (expr), op0, ctxt);
+	  return m_mgr->get_svalue_for_fndecl (TREE_TYPE (expr), op0, ctxt);
 	else if (TREE_CODE (op0) == LABEL_DECL)
-	  return m_mgr->get_svalue2_for_label (TREE_TYPE (expr), op0, ctxt);
+	  return m_mgr->get_svalue_for_label (TREE_TYPE (expr), op0, ctxt);
 #endif
-	const region2 *expr_reg = get_lvalue (op0, ctxt);
-	return m_mgr->get_ptr_svalue2 (TREE_TYPE (expr), expr_reg);
+	const region *expr_reg = get_lvalue (op0, ctxt);
+	return m_mgr->get_ptr_svalue (TREE_TYPE (expr), expr_reg);
       }
       break;
 
@@ -6158,20 +5176,20 @@ region_model2::get_rvalue_1 (path_var pv,
       {
 #if 0
 	tree expr = pv.m_tree;
-	const region2 *obj = get_lvalue (TREE_OPERAND (expr, 0), ctxt);
-	const svalue2 *num_bits = get_rvalue (TREE_OPERAND (expr, 1), ctxt);
-	const svalue2 *bit_offset = get_rvalue (TREE_OPERAND (expr, 2), ctxt);
+	const region *obj = get_lvalue (TREE_OPERAND (expr, 0), ctxt);
+	const svalue *num_bits = get_rvalue (TREE_OPERAND (expr, 1), ctxt);
+	const svalue *bit_offset = get_rvalue (TREE_OPERAND (expr, 2), ctxt);
 	/* FIXME: attempting to add bitwise access will ultimately require
-	   a new svalue2 type for accessing bits from another svalue2
+	   a new svalue type for accessing bits from another svalue
 	   (e.g. to handle the case where the store has no binding for the
-	   bits), and probably a new region2 type also (or maybe just the
-	   latter, using a sub_svalue2 for the former).
+	   bits), and probably a new region type also (or maybe just the
+	   latter, using a sub_svalue for the former).
 	   Is it possible to attempting to spot when we're accessing known
 	   values, and have this possibly return NULL?  */
 	return maybe_get_store_bits (TREE_TYPE (expr), obj, num_bits,
 				     bit_offset);
 #else
-	return m_mgr->get_or_create_unknown_svalue2 (TREE_TYPE (pv.m_tree));
+	return m_mgr->get_or_create_unknown_svalue (TREE_TYPE (pv.m_tree));
 #endif
       }
       break;
@@ -6182,7 +5200,7 @@ region_model2::get_rvalue_1 (path_var pv,
     case RESULT_DECL:
     case ARRAY_REF:
       {
-	const region2 *element_reg = get_lvalue (pv, ctxt);
+	const region *element_reg = get_lvalue (pv, ctxt);
 	return get_store_value (element_reg);
       }
 
@@ -6192,8 +5210,8 @@ region_model2::get_rvalue_1 (path_var pv,
       {
 	tree expr = pv.m_tree;
 	tree arg = TREE_OPERAND (expr, 0);
-	const svalue2 *arg_sval = get_rvalue (arg, ctxt);
-	const svalue2 *sval_unaryop
+	const svalue *arg_sval = get_rvalue (arg, ctxt);
+	const svalue *sval_unaryop
 	  = m_mgr->get_or_create_unaryop (TREE_TYPE (expr), TREE_CODE (expr),
 					  arg_sval);
 	return sval_unaryop;
@@ -6204,16 +5222,16 @@ region_model2::get_rvalue_1 (path_var pv,
     case COMPLEX_CST:
     case VECTOR_CST:
     case STRING_CST:
-      return m_mgr->get_or_create_constant_svalue2 (pv.m_tree);
+      return m_mgr->get_or_create_constant_svalue (pv.m_tree);
 
     case POINTER_PLUS_EXPR:
 	{
 	  tree expr = pv.m_tree;
 	  tree ptr = TREE_OPERAND (expr, 0);
 	  tree offset = TREE_OPERAND (expr, 1);
-	  const svalue2 *ptr_sval = get_rvalue (ptr, ctxt);
-	  const svalue2 *offset_sval = get_rvalue (offset, ctxt);
-	  const svalue2 *sval_binop
+	  const svalue *ptr_sval = get_rvalue (ptr, ctxt);
+	  const svalue *offset_sval = get_rvalue (offset, ctxt);
+	  const svalue *sval_binop
 	    = m_mgr->get_or_create_binop (TREE_TYPE (expr), POINTER_PLUS_EXPR,
 					  ptr_sval, offset_sval);
 	  return sval_binop;
@@ -6226,9 +5244,9 @@ region_model2::get_rvalue_1 (path_var pv,
 	  tree expr = pv.m_tree;
 	  tree arg0 = TREE_OPERAND (expr, 0);
 	  tree arg1 = TREE_OPERAND (expr, 1);
-	  const svalue2 *arg0_sval = get_rvalue (arg0, ctxt);
-	  const svalue2 *arg1_sval = get_rvalue (arg1, ctxt);
-	  const svalue2 *sval_binop
+	  const svalue *arg0_sval = get_rvalue (arg0, ctxt);
+	  const svalue *arg1_sval = get_rvalue (arg1, ctxt);
+	  const svalue *sval_binop
 	    = m_mgr->get_or_create_binop (TREE_TYPE (expr), TREE_CODE (expr),
 					  arg0_sval, arg1_sval);
 	  return sval_binop;
@@ -6237,45 +5255,45 @@ region_model2::get_rvalue_1 (path_var pv,
     case COMPONENT_REF:
     case MEM_REF:
       {
-	const region2 *ref_reg = get_lvalue (pv, ctxt);
+	const region *ref_reg = get_lvalue (pv, ctxt);
 	return get_store_value (ref_reg);
       }
     }
 }
 
-/* Get the value of PV within this region_model2,
+/* Get the value of PV within this region_model,
    emitting any diagnostics to CTXT.  */
 
-const svalue2 *
-region_model2::get_rvalue (path_var pv,
-			   region_model2_context *ctxt)
+const svalue *
+region_model::get_rvalue (path_var pv,
+			   region_model_context *ctxt)
 {
   if (pv.m_tree == NULL_TREE)
     return NULL;
 
-  const svalue2 *result_sval = get_rvalue_1 (pv, ctxt);
+  const svalue *result_sval = get_rvalue_1 (pv, ctxt);
 
   assert_compat_types (result_sval->get_type (), TREE_TYPE (pv.m_tree));
 
   return result_sval;
 }
 
-/* Get the value of EXPR within this region_model2 (assuming the most
+/* Get the value of EXPR within this region_model (assuming the most
    recent stack frame if it's a local).  */
 
-const svalue2 *
-region_model2::get_rvalue (tree expr,
-			   region_model2_context *ctxt)
+const svalue *
+region_model::get_rvalue (tree expr,
+			   region_model_context *ctxt)
 {
   return get_rvalue (path_var (expr, get_stack_depth () - 1), ctxt);
 }
 
 /* FIXME.  */
 
-const svalue2 *
-region_model2::get_store_value (const region2 *reg) const
+const svalue *
+region_model::get_store_value (const region *reg) const
 {
-  const svalue2 *sval
+  const svalue *sval
     = m_store.get_any_binding (m_mgr->get_store_manager (), reg);
   if (sval)
     {
@@ -6285,14 +5303,14 @@ region_model2::get_store_value (const region2 *reg) const
     }
 
   /* Special-case: read at a constant index within a STRING_CST.  */
-  if (const offset_region2 *offset_reg = reg->dyn_cast_offset_region2 ())
+  if (const offset_region *offset_reg = reg->dyn_cast_offset_region ())
     if (tree byte_offset_cst
 	  = offset_reg->get_byte_offset ()->maybe_get_constant ())
-      if (const string_region2 *str_reg
-	  = reg->get_parent_region ()->dyn_cast_string_region2 ())
+      if (const string_region *str_reg
+	  = reg->get_parent_region ()->dyn_cast_string_region ())
 	{
 	  tree string_cst = str_reg->get_string_cst ();
-	  if (const svalue2 *char_sval
+	  if (const svalue *char_sval
 		= maybe_get_char_from_string_cst (string_cst, byte_offset_cst,
 						  m_mgr))
 	    return m_mgr->get_or_create_cast (reg->get_type (), char_sval);
@@ -6300,14 +5318,14 @@ region_model2::get_store_value (const region2 *reg) const
 
   /* Special-case: read the initial char of a STRING_CST.  */
   // FIXME: but only if the cast is to a char?
-  if (const cast_region2 *cast_reg = reg->dyn_cast_cast_region2 ())
-    if (const string_region2 *str_reg
-	= cast_reg->get_original_region ()->dyn_cast_string_region2 ())
+  if (const cast_region *cast_reg = reg->dyn_cast_cast_region ())
+    if (const string_region *str_reg
+	= cast_reg->get_original_region ()->dyn_cast_string_region ())
       if (reg->get_type ()) // FIXME
       {
 	tree string_cst = str_reg->get_string_cst ();
 	tree byte_offset_cst = build_int_cst (integer_type_node, 0);
-	if (const svalue2 *char_sval
+	if (const svalue *char_sval
 	    = maybe_get_char_from_string_cst (string_cst, byte_offset_cst,
 					      m_mgr))
 	  return m_mgr->get_or_create_cast (reg->get_type (), char_sval);
@@ -6322,11 +5340,11 @@ region_model2::get_store_value (const region2 *reg) const
   // FIXME: what about symbolic writes also?
   if (m_store.called_unknown_fn_p ())
     if (reg->get_base_region ()->get_parent_region ()->get_kind ()
-	== region2::RK_GLOBALS)
-      return m_mgr->get_or_create_unknown_svalue2 (reg->get_type ());
+	== region::RK_GLOBALS)
+      return m_mgr->get_or_create_unknown_svalue (reg->get_type ());
 
   /* FIXME: not if touched by symbolic value; handled in
-     binding_cluster2::get_any_binding.  */
+     binding_cluster::get_any_binding.  */
   return m_mgr->get_or_create_initial_value (reg);
 }
 
@@ -6335,14 +5353,14 @@ region_model2::get_store_value (const region2 *reg) const
    after frames are popped.  */
 
 bool
-region_model2::region_exists_p (const region2 *reg) const
+region_model::region_exists_p (const region *reg) const
 {
   /* If within a stack frame, check that the stack frame is live.  */
-  if (const frame_region2 *enclosing_frame = reg->maybe_get_frame_region ())
+  if (const frame_region *enclosing_frame = reg->maybe_get_frame_region ())
     {
       /* Check that the current frame is the enclosing frame, or is called
 	 by it.  */
-      for (const frame_region2 *iter_frame = get_current_frame (); iter_frame;
+      for (const frame_region *iter_frame = get_current_frame (); iter_frame;
 	   iter_frame = iter_frame->get_calling_frame ())
 	if (iter_frame == enclosing_frame)
 	  return true;
@@ -6352,178 +5370,13 @@ region_model2::region_exists_p (const region2 *reg) const
   return true;
 }
 
-/* Build a cast of SRC_EXPR to DST_TYPE, or return NULL_TREE.
-
-   Adapted from gcc::jit::playback::context::build_cast, which in turn is
-   adapted from
-     - c/c-typeck.c:build_c_cast
-     - c/c-convert.c: convert
-     - convert.h
-   Only some kinds of cast are currently supported here.  */
-#if 0
-static tree
-build_cast (tree dst_type, tree src_expr)
-{
-  tree result = targetm.convert_to_type (dst_type, src_expr);
-  if (result)
-    return result;
-  enum tree_code dst_code = TREE_CODE (dst_type);
-  switch (dst_code)
-    {
-    case INTEGER_TYPE:
-    case ENUMERAL_TYPE:
-      result = convert_to_integer (dst_type, src_expr);
-      goto maybe_fold;
-
-    case BOOLEAN_TYPE:
-      /* Compare with c_objc_common_truthvalue_conversion and
-	 c_common_truthvalue_conversion. */
-      /* For now, convert to: (src_expr != 0)  */
-      result = build2 (NE_EXPR, dst_type,
-		       src_expr,
-		       build_int_cst (TREE_TYPE (src_expr), 0));
-      goto maybe_fold;
-
-    case REAL_TYPE:
-      result = convert_to_real (dst_type, src_expr);
-      goto maybe_fold;
-
-    case POINTER_TYPE:
-      result = build1 (NOP_EXPR, dst_type, src_expr);
-      goto maybe_fold;
-
-    default:
-      return NULL_TREE;
-
-    maybe_fold:
-      if (TREE_CODE (result) != C_MAYBE_CONST_EXPR)
-	result = fold (result);
-      return result;
-    }
-}
-#endif
-
-/* If the type of SID's underlying value is DST_TYPE, return SID.
-   Otherwise, attempt to create (or reuse) an svalue2 representing an access
-   of SID as a DST_TYPE and return that value's svalue2_id.  */
-#if 0
-svalue2_id
-region_model2::maybe_cast_1 (tree dst_type, const svalue2 *sval)
-{
-  const svalue2 *sval = get_svalue2 (sid);
-  tree src_type = sval->get_type ();
-  if (src_type == dst_type)
-    return sid;
-
-  if (POINTER_TYPE_P (dst_type)
-      || POINTER_TYPE_P (src_type))
-    {
-      /* Pointer to region2.  */
-      if (region_svalue2 *ptr_sval = sval->dyn_cast_region_svalue2 ())
-	return get_or_create_ptr_svalue2 (dst_type, ptr_sval->get_pointee ());
-
-      /* Unknown pointer?   Get or create a new unknown pointer of the
-	 correct type, preserving the equality between the pointers.  */
-      if (sval->dyn_cast_unknown_svalue2 ())
-	{
-	  equiv_class &ec = m_constraints->get_equiv_class (sid);
-
-	  /* Look for an existing pointer of the correct type within the EC.  */
-	  int i;
-	  const svalue2 **equiv_sval;
-	  FOR_EACH_VEC_ELT (ec.m_vars, i, equiv_sval)
-	    {
-	      const svalue2 *equiv_val = get_svalue2 (*equiv_sval);
-	      if (equiv_val->get_type () == dst_type)
-		return *equiv_sval;
-	    }
-
-	  /* Otherwise, create a new unknown pointer of the correct type.  */
-	  const svalue2 *unknown_sval = new unknown_svalue2 (dst_type);
-	  const svalue2 *new_ptr_sval = add_svalue2 (unknown_sval);
-	  m_constraints->add_constraint (sid, EQ_EXPR, new_ptr_sval);
-	  return new_ptr_sval;
-	}
-    }
-
-  /* Attempt to cast constants.  */
-  if (tree src_cst = sval->maybe_get_constant ())
-    {
-      if (tree dst = build_cast (dst_type, src_cst))
-	if (CONSTANT_CLASS_P (dst))
-	  return get_or_create_constant_svalue2 (dst);
-    }
-
-  /* Otherwise, return a new unknown value.  */
-  const svalue2 *unknown_sval = new unknown_svalue2 (dst_type);
-  return add_svalue2 (unknown_sval);
-}
-
-/* If the type of SID's underlying value is DST_TYPE, return SID.
-   Otherwise, attempt to create (or reuse) an svalue2 representing an access
-   of SID as a DST_TYPE and return that value's svalue2_id.
-
-   If the result != SID, then call CTXT's on_cast vfunc (if CTXT is non-NULL),
-   so that sm-state can be propagated from SID to the result.  */
-
-svalue2_id
-region_model2::maybe_cast (tree dst_type, const svalue2 *sval,
-			  region_model2_context *ctxt)
-{
-  const svalue2 *result = maybe_cast_1 (dst_type, sid);
-  if (result != sid)
-    if (ctxt)
-      {
-	/* Notify ctxt about a cast, so any sm-state can be copied.  */
-	ctxt->on_cast (sid, result);
-      }
-  return result;
-}
-#endif
-
-/* Ensure that the region2 for OBJ_REG has a child region2 for FIELD;
-   return the child region2's region2_id.  */
-#if 0
-region2_id
-region_model2::get_field_region (region2 *struct_or_union_reg, tree field,
-				 region_model2_context *ctxt)
-{
-  struct_or_union_region2 *sou_reg
-    = get_region2<struct_or_union_region2> (struct_or_union_reg);
-
-  /* Inherit constness from parent type.  */
-  const int qual_mask = TYPE_QUAL_CONST;
-  int sou_quals = TYPE_QUALS (sou_reg->get_type ()) & qual_mask;
-  tree field_type = TREE_TYPE (field);
-  tree field_type_with_quals = build_qualified_type (field_type, sou_quals);
-
-  // TODO: maybe convert to a vfunc?
-  if (sou_reg->get_kind () == RK_UNION)
-    {
-      /* Union.
-	 Get a view of the union as a whole, with the type of the field.  */
-      region2 *view_reg
-	= get_or_create_view (struct_or_union_reg, field_type_with_quals, ctxt);
-      return view_reg;
-    }
-  else
-    {
-      /* Struct.  */
-      region2 *child_reg
-	= sou_reg->get_or_create (this, struct_or_union_reg, field,
-				  field_type_with_quals, ctxt);
-      return child_reg;
-    }
-}
-#endif
-
-/* Get a region2 for referencing PTR_SVAL, creating a region2 if need be, and
+/* Get a region for referencing PTR_SVAL, creating a region if need be, and
    potentially generating warnings via CTXT.
    PTR_TREE if non-NULL can be used when emitting diagnostics.  */
 
-const region2 *
-region_model2::deref_rvalue (const svalue2 *ptr_sval, tree ptr_tree,
-			     region_model2_context *ctxt)
+const region *
+region_model::deref_rvalue (const svalue *ptr_sval, tree ptr_tree,
+			     region_model_context *ctxt)
 {
   gcc_assert (ptr_sval);
 
@@ -6532,48 +5385,48 @@ region_model2::deref_rvalue (const svalue2 *ptr_sval, tree ptr_tree,
     default:
       gcc_unreachable ();
 
-    case svalue2::SK_REGION:
+    case svalue::SK_REGION:
       {
-	const region_svalue2 *region2_sval
-	  = as_a <const region_svalue2 *> (ptr_sval);
-	return region2_sval->get_pointee ();
+	const region_svalue *region_sval
+	  = as_a <const region_svalue *> (ptr_sval);
+	return region_sval->get_pointee ();
       }
 
-    case svalue2::SK_BINOP:
+    case svalue::SK_BINOP:
 #if 1
       {
-	const binop_svalue2 *binop_sval
-	  = as_a <const binop_svalue2 *> (ptr_sval);
+	const binop_svalue *binop_sval
+	  = as_a <const binop_svalue *> (ptr_sval);
 	switch (binop_sval->get_op ())
 	  {
 	  case POINTER_PLUS_EXPR:
 	    {
 	      /* If we have a symbolic value expressing pointer arithmentic,
 		 try to convert it to a suitable region.  */
-	      /* FIXME: but should it be an element_region2?  that expresses
+	      /* FIXME: but should it be an element_region?  that expresses
 		 things via element indices, rather than via byte offsets.  */
 	      /* Perhaps instead we should capture this as an offset relative
 		 to a base region in region_offset?  */
-	      const region2 *parent_region
+	      const region *parent_region
 		= deref_rvalue (binop_sval->get_arg0 (), NULL_TREE, ctxt);
-	      const svalue2 *offset = binop_sval->get_arg1 ();
+	      const svalue *offset = binop_sval->get_arg1 ();
 	      tree type= TREE_TYPE (ptr_sval->get_type ());
 	      return m_mgr->get_offset_region (parent_region, type, offset);
 	    }
 	  default:
-	    goto create_symbolic_region2;
+	    goto create_symbolic_region;
 	  }
       }
 #endif
-    case svalue2::SK_CONSTANT:
-    case svalue2::SK_INITIAL:
-    case svalue2::SK_UNARYOP:
-    case svalue2::SK_SUB:
-    case svalue2::SK_WIDENING:
-    case svalue2::SK_CONJURED:
-      goto create_symbolic_region2;
-
-    case svalue2::SK_POISONED:
+    case svalue::SK_CONSTANT:
+    case svalue::SK_INITIAL:
+    case svalue::SK_UNARYOP:
+    case svalue::SK_SUB:
+    case svalue::SK_WIDENING:
+    case svalue::SK_CONJURED:
+      goto create_symbolic_region;
+
+    case svalue::SK_POISONED:
       {
 	if (ctxt)
 	  {
@@ -6585,64 +5438,51 @@ region_model2::deref_rvalue (const svalue2 *ptr_sval, tree ptr_tree,
 	      ptr = ptr_tree;
 	    if (ptr)
 	      {
-		const poisoned_svalue2 *poisoned_sval
-		  = as_a <const poisoned_svalue2 *> (ptr_sval);
+		const poisoned_svalue *poisoned_sval
+		  = as_a <const poisoned_svalue *> (ptr_sval);
 		enum poison_kind pkind = poisoned_sval->get_poison_kind ();
-		ctxt->warn (new poisoned_value_diagnostic2 (ptr, pkind));
+		ctxt->warn (new poisoned_value_diagnostic (ptr, pkind));
 	      }
 	  }
-	goto create_symbolic_region2;
+	goto create_symbolic_region;
       }
 
-    case svalue2::SK_UNKNOWN:
+    case svalue::SK_UNKNOWN:
       {
-      create_symbolic_region2:
-	/* We need a symbolic_region2 to represent this unknown region2.
+      create_symbolic_region:
+	/* We need a symbolic_region to represent this unknown region.
 	   FIXME:
 	   We don't know if it on the heap, stack, or a global,
-	   so use the root region2 as parent.  */
-	const region2 *new_reg = m_mgr->get_symbolic_region (ptr_sval);
+	   so use the root region as parent.  */
+	const region *new_reg = m_mgr->get_symbolic_region (ptr_sval);
 #if 0
-	/* We need to write the region2 back into the pointer,
-	   or we'll get a new, different region2 each time.
+	/* We need to write the region back into the pointer,
+	   or we'll get a new, different region each time.
 	   We do this by changing the meaning of ptr_sval, replacing
-	   the unknown value with the ptr to the new region2.
+	   the unknown value with the ptr to the new region.
 	   We replace the meaning of the ID rather than simply writing
 	   to PTR's lvalue since there could be several places sharing
 	   the same unknown ptr value.  */
-	const svalue2 *ptr_val
-	  = new region_svalue2 (ptr_sval->get_type (), new_reg);
-	replace_svalue2 (ptr_sval, ptr_val);
+	const svalue *ptr_val
+	  = new region_svalue (ptr_sval->get_type (), new_reg);
+	replace_svalue (ptr_sval, ptr_val);
 #endif
 	return new_reg;
       }
 
-    case svalue2::SK_SETJMP:
-      goto create_symbolic_region2;
+    case svalue::SK_SETJMP:
+      goto create_symbolic_region;
     }
 
   gcc_unreachable ();
 }
 
-#if 0
-
-/* Get a region2 *for referencing PTR, creating a region2 if need be, and
-   potentially generating warnings via CTXT.  */
-
-region2_id
-region_model2::deref_rvalue (tree ptr, region_model2_context *ctxt)
-{
-  const svalue2 *ptr_sval = get_rvalue (ptr, ctxt);
-  return deref_rvalue (ptr_sval, ctxt);
-}
-#endif
-
-/* Set the value of the region2 given by LHS_REG to the value given
+/* Set the value of the region given by LHS_REG to the value given
    by RHS_SVAL.  */
 
 void
-region_model2::set_value (const region2 *lhs_reg, const svalue2 *rhs_sval,
-			  region_model2_context */*ctxt*/)
+region_model::set_value (const region *lhs_reg, const svalue *rhs_sval,
+			  region_model_context */*ctxt*/)
 {
   gcc_assert (lhs_reg);
   gcc_assert (rhs_sval);
@@ -6651,14 +5491,14 @@ region_model2::set_value (const region2 *lhs_reg, const svalue2 *rhs_sval,
 		     BK_direct);
 }
 
-/* Set the value of the region2 given by LHS to the value given
+/* Set the value of the region given by LHS to the value given
    by RHS.  */
 
 void
-region_model2::set_value (tree lhs, tree rhs, region_model2_context *ctxt)
+region_model::set_value (tree lhs, tree rhs, region_model_context *ctxt)
 {
-  const region2 *lhs_reg = get_lvalue (lhs, ctxt);
-  const svalue2 *rhs_sval = get_rvalue (rhs, ctxt);
+  const region *lhs_reg = get_lvalue (lhs, ctxt);
+  const svalue *rhs_sval = get_rvalue (rhs, ctxt);
   gcc_assert (lhs_reg);
   gcc_assert (rhs_sval);
   set_value (lhs_reg, rhs_sval, ctxt);
@@ -6667,7 +5507,7 @@ region_model2::set_value (tree lhs, tree rhs, region_model2_context *ctxt)
 /* FIXME.  */
 
 void
-region_model2::clobber_region (const region2 *reg)
+region_model::clobber_region (const region *reg)
 {
   m_store.clobber_region (m_mgr->get_store_manager(), reg);
 }
@@ -6675,7 +5515,7 @@ region_model2::clobber_region (const region2 *reg)
 /* FIXME.  */
 
 void
-region_model2::purge_region (const region2 *reg)
+region_model::purge_region (const region *reg)
 {
   m_store.purge_region (m_mgr->get_store_manager(), reg);
 }
@@ -6683,7 +5523,7 @@ region_model2::purge_region (const region2 *reg)
 /* Zero-fill REG.  */
 
 void
-region_model2::zero_fill_region (const region2 *reg)
+region_model::zero_fill_region (const region *reg)
 {
   m_store.zero_fill_region (m_mgr->get_store_manager(), reg);
 }
@@ -6691,7 +5531,7 @@ region_model2::zero_fill_region (const region2 *reg)
 /* Mark REG as having unknown content.  */
 
 void
-region_model2::mark_region_as_unknown (const region2 *reg)
+region_model::mark_region_as_unknown (const region *reg)
 {
   m_store.mark_region_as_unknown (m_mgr->get_store_manager(), reg);
 }
@@ -6700,9 +5540,9 @@ region_model2::mark_region_as_unknown (const region2 *reg)
    this model.  */
 
 tristate
-region_model2::eval_condition (const svalue2 *lhs,
+region_model::eval_condition (const svalue *lhs,
 			       enum tree_code op,
-			       const svalue2 *rhs) const
+			       const svalue *rhs) const
 {
   /* For now, make no attempt to capture constraints on floating-point
      values.  */
@@ -6715,20 +5555,20 @@ region_model2::eval_condition (const svalue2 *lhs,
     return ts;
 
   /* Otherwise, try constraints.  */
-  return m_constraints2->eval_condition (lhs, op, rhs);
+  return m_constraints->eval_condition (lhs, op, rhs);
 }
 
 /* Determine what is known about the condition "LHS_SVAL OP RHS_SVAL" within
    this model, without resorting to the constraint_manager.
 
-   This is exposed so that impl_region_model2_context::on_state_leak can
-   check for equality part-way through region_model2::purge_unused_svalue2s
+   This is exposed so that impl_region_model_context::on_state_leak can
+   check for equality part-way through region_model::purge_unused_svalues
    without risking creating new ECs.  */
 
 tristate
-region_model2::eval_condition_without_cm (const svalue2 *lhs,
+region_model::eval_condition_without_cm (const svalue *lhs,
 					  enum tree_code op,
-					  const svalue2 *rhs) const
+					  const svalue *rhs) const
 {
   gcc_assert (lhs);
   gcc_assert (rhs);
@@ -6747,12 +5587,12 @@ region_model2::eval_condition_without_cm (const svalue2 *lhs,
 
   if (lhs == rhs)
     {
-      /* If we have the same svalue2, then we have equality
+      /* If we have the same svalue, then we have equality
 	 (apart from NaN-handling).
 	 TODO: should this definitely be the case for poisoned values?  */
       /* Poisoned and unknown values are "unknowable".  */
-      if (lhs->get_kind () == svalue2::SK_POISONED
-	  || lhs->get_kind () == svalue2::SK_UNKNOWN)
+      if (lhs->get_kind () == svalue::SK_POISONED
+	  || lhs->get_kind () == svalue::SK_UNKNOWN)
 	return tristate::TS_UNKNOWN;
 
       switch (op)
@@ -6773,30 +5613,30 @@ region_model2::eval_condition_without_cm (const svalue2 *lhs,
 	}
     }
 
-  /* If we have a pair of region_svalue2s, compare them.  */
-  if (const region_svalue2 *lhs_ptr = lhs->dyn_cast_region_svalue2 ())
-    if (const region_svalue2 *rhs_ptr = rhs->dyn_cast_region_svalue2 ())
+  /* If we have a pair of region_svalues, compare them.  */
+  if (const region_svalue *lhs_ptr = lhs->dyn_cast_region_svalue ())
+    if (const region_svalue *rhs_ptr = rhs->dyn_cast_region_svalue ())
       {
-	tristate res = region_svalue2::eval_condition (lhs_ptr, op, rhs_ptr);
+	tristate res = region_svalue::eval_condition (lhs_ptr, op, rhs_ptr);
 	if (res.is_known ())
 	  return res;
 	/* Otherwise, only known through constraints.  */
       }
 
   /* If we have a pair of constants, compare them.  */
-  if (const constant_svalue2 *cst_lhs = lhs->dyn_cast_constant_svalue2 ())
-    if (const constant_svalue2 *cst_rhs = rhs->dyn_cast_constant_svalue2 ())
-      return constant_svalue2::eval_condition (cst_lhs, op, cst_rhs);
+  if (const constant_svalue *cst_lhs = lhs->dyn_cast_constant_svalue ())
+    if (const constant_svalue *cst_rhs = rhs->dyn_cast_constant_svalue ())
+      return constant_svalue::eval_condition (cst_lhs, op, cst_rhs);
 
-  /* Handle comparison of a region_svalue2 against zero.  */
+  /* Handle comparison of a region_svalue against zero.  */
 
-  if (const region_svalue2 *ptr = lhs->dyn_cast_region_svalue2 ())
-    if (const constant_svalue2 *cst_rhs = rhs->dyn_cast_constant_svalue2 ())
+  if (const region_svalue *ptr = lhs->dyn_cast_region_svalue ())
+    if (const constant_svalue *cst_rhs = rhs->dyn_cast_constant_svalue ())
       if (zerop (cst_rhs->get_constant ()))
 	{
-	  /* A region_svalue2 is a non-NULL pointer, except in certain
-	     special cases (see the comment for region2::non_null_p.  */
-	  const region2 *pointee = ptr->get_pointee ();
+	  /* A region_svalue is a non-NULL pointer, except in certain
+	     special cases (see the comment for region::non_null_p.  */
+	  const region *pointee = ptr->get_pointee ();
 	  if (pointee->non_null_p (*this))
 	    {
 	      switch (op)
@@ -6819,22 +5659,22 @@ region_model2::eval_condition_without_cm (const svalue2 *lhs,
 
   /* Handle rejection of equality for comparisons of the initial values of
      "external" values (such as params) with the address of locals.  */
-  if (const initial_svalue2 *init_lhs = lhs->dyn_cast_initial_svalue2 ())
-    if (const region_svalue2 *rhs_ptr = rhs->dyn_cast_region_svalue2 ())
+  if (const initial_svalue *init_lhs = lhs->dyn_cast_initial_svalue ())
+    if (const region_svalue *rhs_ptr = rhs->dyn_cast_region_svalue ())
       {
 	tristate res = compare_initial_and_pointer (init_lhs, rhs_ptr);
 	if (res.is_known ())
 	  return res;
       }
-  if (const initial_svalue2 *init_rhs = rhs->dyn_cast_initial_svalue2 ())
-    if (const region_svalue2 *lhs_ptr = lhs->dyn_cast_region_svalue2 ())
+  if (const initial_svalue *init_rhs = rhs->dyn_cast_initial_svalue ())
+    if (const region_svalue *lhs_ptr = lhs->dyn_cast_region_svalue ())
       {
 	tristate res = compare_initial_and_pointer (init_rhs, lhs_ptr);
 	if (res.is_known ())
 	  return res;
       }
 
-  if (const widening_svalue2 *widen_lhs = lhs->dyn_cast_widening_svalue2 ())
+  if (const widening_svalue *widen_lhs = lhs->dyn_cast_widening_svalue ())
     if (tree rhs_cst = rhs->maybe_get_constant ())
       {
 	tristate res = widen_lhs->eval_condition_without_cm (op, rhs_cst);
@@ -6842,7 +5682,7 @@ region_model2::eval_condition_without_cm (const svalue2 *lhs,
 	  return res;
       }
 #if 0
-  if (const widening_svalue2 *widen_rhs = rhs->dyn_cast_widening_svalue2 ())
+  if (const widening_svalue *widen_rhs = rhs->dyn_cast_widening_svalue ())
     {
       gcc_unreachable ();
     }
@@ -6851,20 +5691,20 @@ region_model2::eval_condition_without_cm (const svalue2 *lhs,
   return tristate::TS_UNKNOWN;
 }
 
-/* Subroutine of region_model2::eval_condition_without_cm, for rejecting
+/* Subroutine of region_model::eval_condition_without_cm, for rejecting
    equality of INIT_VAL(PARM) with &LOCAL.  */
 
 tristate
-region_model2::compare_initial_and_pointer (const initial_svalue2 *init,
-					    const region_svalue2 *ptr) const
+region_model::compare_initial_and_pointer (const initial_svalue *init,
+					    const region_svalue *ptr) const
 {
-  const region2 *pointee = ptr->get_pointee ();
+  const region *pointee = ptr->get_pointee ();
 
   /* If we have a pointer to something within a stack frame, it can't be the
      initial value of a param.  */
   if (pointee->maybe_get_frame_region ())
     {
-      const region2 *reg = init->get_region ();
+      const region *reg = init->get_region ();
       if (tree reg_decl = reg->maybe_get_decl ())
 	if (TREE_CODE (reg_decl) == SSA_NAME)
 	  {
@@ -6879,22 +5719,22 @@ region_model2::compare_initial_and_pointer (const initial_svalue2 *init,
   return tristate::TS_UNKNOWN;
 }
 
-/* Attempt to add the constraint "LHS OP RHS" to this region_model2.
+/* Attempt to add the constraint "LHS OP RHS" to this region_model.
    If it is consistent with existing constraints, add it, and return true.
    Return false if it contradicts existing constraints.
    Use CTXT for reporting any diagnostics associated with the accesses.  */
 
 bool
-region_model2::add_constraint (tree lhs, enum tree_code op, tree rhs,
-			       region_model2_context *ctxt)
+region_model::add_constraint (tree lhs, enum tree_code op, tree rhs,
+			       region_model_context *ctxt)
 {
   /* For now, make no attempt to capture constraints on floating-point
      values.  */
   if (FLOAT_TYPE_P (TREE_TYPE (lhs)) || FLOAT_TYPE_P (TREE_TYPE (rhs)))
     return true;
 
-  const svalue2 *lhs_sval = get_rvalue (lhs, ctxt);
-  const svalue2 *rhs_sval = get_rvalue (rhs, ctxt);
+  const svalue *lhs_sval = get_rvalue (lhs, ctxt);
+  const svalue *rhs_sval = get_rvalue (rhs, ctxt);
 
   tristate t_cond = eval_condition (lhs_sval, op, rhs_sval);
 
@@ -6908,18 +5748,18 @@ region_model2::add_constraint (tree lhs, enum tree_code op, tree rhs,
     return false;
 
   /* Store the constraint.  */
-  m_constraints2->add_constraint (lhs_sval, op, rhs_sval);
+  m_constraints->add_constraint (lhs_sval, op, rhs_sval);
 
   add_any_constraints_from_ssa_def_stmt (lhs, op, rhs, ctxt);
 
 #if 0
-  /* If we now know a symbolic_region2 is non-NULL, clear its
+  /* If we now know a symbolic_region is non-NULL, clear its
      m_possibly_null.  */
   if (zerop (rhs) && op == NE_EXPR)
-    if (region_svalue2 *ptr = get_svalue2 (lhs_sval)->dyn_cast_region_svalue2 ())
+    if (region_svalue *ptr = get_svalue (lhs_sval)->dyn_cast_region_svalue ())
       {
-	region2 *pointee = get_region2 (ptr->get_pointee ());
-	if (symbolic_region2 *sym_reg = pointee->dyn_cast_symbolic_region2 ())
+	region *pointee = get_region (ptr->get_pointee ());
+	if (symbolic_region *sym_reg = pointee->dyn_cast_symbolic_region ())
 	  sym_reg->m_possibly_null = false;
       }
 #endif
@@ -6934,7 +5774,7 @@ region_model2::add_constraint (tree lhs, enum tree_code op, tree rhs,
   return true;
 }
 
-/* Subroutine of region_model2::add_constraint for handling optimized
+/* Subroutine of region_model::add_constraint for handling optimized
    && and || conditionals.
 
    If we have an SSA_NAME for a boolean compared against 0,
@@ -6953,10 +5793,10 @@ region_model2::add_constraint (tree lhs, enum tree_code op, tree rhs,
       p_8 != 0B.  */
 
 void
-region_model2::add_any_constraints_from_ssa_def_stmt (tree lhs,
+region_model::add_any_constraints_from_ssa_def_stmt (tree lhs,
 						     enum tree_code op,
 						     tree rhs,
-						     region_model2_context *ctxt)
+						     region_model_context *ctxt)
 {
   if (TREE_CODE (lhs) != SSA_NAME)
     return;
@@ -6978,10 +5818,10 @@ region_model2::add_any_constraints_from_ssa_def_stmt (tree lhs,
    where the result OP RHS.  */
 
 void
-region_model2::add_any_constraints_from_gassign (enum tree_code op,
+region_model::add_any_constraints_from_gassign (enum tree_code op,
 						tree rhs,
 						const gassign *assign,
-						region_model2_context *ctxt)
+						region_model_context *ctxt)
 {
   /* We have either
      - "LHS != false" (i.e. LHS is true), or
@@ -7050,10 +5890,10 @@ region_model2::add_any_constraints_from_gassign (enum tree_code op,
    where the result OP RHS.  */
 
 void
-region_model2::add_any_constraints_from_gcall (enum tree_code op,
+region_model::add_any_constraints_from_gcall (enum tree_code op,
 					       tree rhs,
 					       const gcall *call,
-					       region_model2_context *ctxt)
+					       region_model_context *ctxt)
 {
   if (gimple_call_builtin_p (call, BUILT_IN_EXPECT)
       || gimple_call_builtin_p (call, BUILT_IN_EXPECT_WITH_PROBABILITY)
@@ -7069,10 +5909,10 @@ region_model2::add_any_constraints_from_gcall (enum tree_code op,
    Use CTXT for reporting any diagnostics associated with the accesses.  */
 
 tristate
-region_model2::eval_condition (tree lhs,
+region_model::eval_condition (tree lhs,
 			       enum tree_code op,
 			       tree rhs,
-			       region_model2_context *ctxt)
+			       region_model_context *ctxt)
 {
   /* For now, make no attempt to model constraints on floating-point
      values.  */
@@ -7084,43 +5924,18 @@ region_model2::eval_condition (tree lhs,
 			 get_rvalue (rhs, ctxt));
 }
 
-/* If SID is a constant value, return the underlying tree constant.
-   Otherwise, return NULL_TREE.  */
-#if 0
-tree
-region_model2::maybe_get_constant (const svalue2 *sval) const
-{
-  gcc_assert (!sid.null_p ());
-  svalue2 *sval = get_svalue2 (sid);
-  return sval->maybe_get_constant ();
-}
-#endif
-
-/* Create a new child region2 of the heap (creating the heap region2 if
-   necessary).
-   Return the region2 *of the new child region2.  */
-#if 0
-region2_id
-region_model2::add_new_malloc_region2 ()
-{
-  region2 *heap_reg
-    = get_root_region2 ()->ensure_heap_region2 (this);
-  return add_region2 (new symbolic_region2 (heap_reg, NULL_TREE, true));
-}
-#endif
-
 /* Attempt to return a path_var that represents SVAL, or return NULL_TREE.
    Use VISITED to prevent infinite mutual recursion with the overload for
    regions.  */
 
 path_var
-region_model2::get_representative_path_var (const svalue2 *sval,
-					    hash_set <const svalue2 *> *visited) const
+region_model::get_representative_path_var (const svalue *sval,
+					    hash_set <const svalue *> *visited) const
 {
   if (sval == NULL)
     return path_var (NULL_TREE, 0);
 
-  if (const svalue2 *cast_sval = sval->maybe_undo_cast ())
+  if (const svalue *cast_sval = sval->maybe_undo_cast ())
     sval = cast_sval;
 
   /* Prevent infinite recursion.  */
@@ -7135,9 +5950,9 @@ region_model2::get_representative_path_var (const svalue2 *sval,
     pvs.safe_push (path_var (cst, 0));
 
   /* Handle string literals and various other pointers.  */
-  if (const region_svalue2 *ptr_sval = sval->dyn_cast_region_svalue2 ())
+  if (const region_svalue *ptr_sval = sval->dyn_cast_region_svalue ())
     {
-      const region2 *reg = ptr_sval->get_pointee ();
+      const region *reg = ptr_sval->get_pointee ();
       if (path_var pv = get_representative_path_var (reg, visited))
 	return path_var (build1 (ADDR_EXPR,
 				 TREE_TYPE (sval->get_type ()),
@@ -7147,13 +5962,13 @@ region_model2::get_representative_path_var (const svalue2 *sval,
 
 #if CONJURED_VALUES_FOR_UNKNOWN_FNCALLS
   /* If we have a sub_svalue, look for ways to represent the parent.  */
-  if (const sub_svalue2 *sub_sval = sval->dyn_cast_sub_svalue2 ())
+  if (const sub_svalue *sub_sval = sval->dyn_cast_sub_svalue ())
     {
-      const svalue2 *parent_sval = sub_sval->get_parent ();
-      const region2 *subreg = sub_sval->get_subregion ();
+      const svalue *parent_sval = sub_sval->get_parent ();
+      const region *subreg = sub_sval->get_subregion ();
       if (path_var parent_pv
 	    = get_representative_path_var (parent_sval, visited))
-	if (const field_region2 *field_reg = subreg->dyn_cast_field_region2 ())
+	if (const field_region *field_reg = subreg->dyn_cast_field_region ())
 	  return path_var (build3 (COMPONENT_REF,
 				   sval->get_type (),
 				   parent_pv.m_tree,
@@ -7170,14 +5985,14 @@ region_model2::get_representative_path_var (const svalue2 *sval,
   return pvs[0];
 
 #if 0
-  /* Find the first region2 that stores the value (e.g. a local) and
+  /* Find the first region that stores the value (e.g. a local) and
      generate a representative tree for it.  */
   unsigned i;
-  region2 *region2;
-  FOR_EACH_VEC_ELT (m_region2s, i, region2)
-    if (sid == region2->get_value_direct ())
+  region *region;
+  FOR_EACH_VEC_ELT (m_regions, i, region)
+    if (sid == region->get_value_direct ())
       {
-	path_var pv = get_representative_path_var (region2_id::from_int (i));
+	path_var pv = get_representative_path_var (region_id::from_int (i));
 	if (pv.m_tree)
 	  return pv.m_tree;
       }
@@ -7189,51 +6004,51 @@ region_model2::get_representative_path_var (const svalue2 *sval,
 /* Attempt to return a tree that represents SVAL, or return NULL_TREE.  */
 
 tree
-region_model2::get_representative_tree (const svalue2 *sval) const
+region_model::get_representative_tree (const svalue *sval) const
 {
-  hash_set <const svalue2 *> visited;
+  hash_set <const svalue *> visited;
   return get_representative_path_var (sval, &visited).m_tree;
 }
 
 /* Attempt to return a path_var that represents REG, or return
    the NULL path_var.
-   For example, a region2 for a field of a local would be a path_var
+   For example, a region for a field of a local would be a path_var
    wrapping a COMPONENT_REF.
    Use VISITED to prevent infinite mutual recursion with the overload for
-   svalue2s.  */
+   svalues.  */
 
 path_var
-region_model2::get_representative_path_var (const region2 *reg,
-					    hash_set <const svalue2 *> *visited) const
+region_model::get_representative_path_var (const region *reg,
+					    hash_set <const svalue *> *visited) const
 {
   switch (reg->get_kind ())
     {
     default:
       gcc_unreachable ();
 
-    case region2::RK_FRAME:
-    case region2::RK_GLOBALS:
-    case region2::RK_CODE:
-    case region2::RK_HEAP:
-    case region2::RK_STACK:
-    case region2::RK_ROOT:
+    case region::RK_FRAME:
+    case region::RK_GLOBALS:
+    case region::RK_CODE:
+    case region::RK_HEAP:
+    case region::RK_STACK:
+    case region::RK_ROOT:
        /* Regions that represent memory spaces are not expressible as trees.  */
       return path_var (NULL_TREE, 0);
 
-    case region2::RK_FUNCTION:
+    case region::RK_FUNCTION:
       {
-	const function_region2 *function_reg
-	  = as_a <const function_region2 *> (reg);
+	const function_region *function_reg
+	  = as_a <const function_region *> (reg);
 	return path_var (function_reg->get_fndecl (), 0);
       }
-    case region2::RK_LABEL:
+    case region::RK_LABEL:
       gcc_unreachable (); // TODO
 
-    case region2::RK_SYMBOLIC:
+    case region::RK_SYMBOLIC:
       {
-	const symbolic_region2 *symbolic_reg
-	  = as_a <const symbolic_region2 *> (reg);
-	const svalue2 *pointer = symbolic_reg->get_pointer ();
+	const symbolic_region *symbolic_reg
+	  = as_a <const symbolic_region *> (reg);
+	const svalue *pointer = symbolic_reg->get_pointer ();
 	path_var pointer_pv = get_representative_path_var (pointer, visited);
 	if (!pointer_pv)
 	  return path_var (NULL_TREE, 0);
@@ -7244,14 +6059,14 @@ region_model2::get_representative_path_var (const region2 *reg,
 				 offset),
 			 pointer_pv.m_stack_depth);
       }
-    case region2::RK_DECL:
+    case region::RK_DECL:
       {
-	const decl_region2 *decl_reg = as_a <const decl_region2 *> (reg);
+	const decl_region *decl_reg = as_a <const decl_region *> (reg);
 	return path_var (decl_reg->get_decl (), decl_reg->get_stack_depth ());
       }
-    case region2::RK_FIELD:
+    case region::RK_FIELD:
       {
-	const field_region2 *field_reg = as_a <const field_region2 *> (reg);
+	const field_region *field_reg = as_a <const field_region *> (reg);
 	path_var parent_pv
 	  = get_representative_path_var (reg->get_parent_region (), visited);
 	if (!parent_pv)
@@ -7264,10 +6079,10 @@ region_model2::get_representative_path_var (const region2 *reg,
 			 parent_pv.m_stack_depth);
       }
 
-    case region2::RK_ELEMENT:
+    case region::RK_ELEMENT:
       {
-	const element_region2 *element_reg
-	  = as_a <const element_region2 *> (reg);
+	const element_region *element_reg
+	  = as_a <const element_region *> (reg);
 	path_var parent_pv
 	  = get_representative_path_var (reg->get_parent_region (), visited);
 	if (!parent_pv)
@@ -7283,10 +6098,10 @@ region_model2::get_representative_path_var (const region2 *reg,
 			 parent_pv.m_stack_depth);
       }
 
-    case region2::RK_OFFSET:
+    case region::RK_OFFSET:
       {
-	const offset_region2 *offset_reg
-	  = as_a <const offset_region2 *> (reg);
+	const offset_region *offset_reg
+	  = as_a <const offset_region *> (reg);
 	path_var parent_pv
 	  = get_representative_path_var (reg->get_parent_region (), visited);
 	if (!parent_pv)
@@ -7302,7 +6117,7 @@ region_model2::get_representative_path_var (const region2 *reg,
 			 parent_pv.m_stack_depth);
       }
 
-    case region2::RK_CAST:
+    case region::RK_CAST:
       {
 	path_var parent_pv
 	  = get_representative_path_var (reg->get_parent_region (), visited);
@@ -7314,71 +6129,29 @@ region_model2::get_representative_path_var (const region2 *reg,
 			 parent_pv.m_stack_depth);
       }
 
-    case region2::RK_HEAP_ALLOCATED:
-    case region2::RK_ALLOCA:
+    case region::RK_HEAP_ALLOCATED:
+    case region::RK_ALLOCA:
       /* No good way to express heap-allocated/alloca regions as trees.  */
       return path_var (NULL_TREE, 0);
 
-    case region2::RK_STRING:
+    case region::RK_STRING:
       {
-	const string_region2 *string_reg = as_a <const string_region2 *> (reg);
+	const string_region *string_reg = as_a <const string_region *> (reg);
 	return path_var (string_reg->get_string_cst (), 0);
       }
 
-    case region2::RK_UNKNOWN:
+    case region::RK_UNKNOWN:
       return path_var (NULL_TREE, 0);
     }
 }
 
-/* Locate all region2s that directly have value SVAL and append representative
-   path_var instances for them into *OUT.  */
-/* FIXME: other ways of getting to the svalue e.g. for initial_svalue2s?
-   Also: this might not be the best human-readable description to use.  */
-#if 0
-void
-region_model2::get_path_vars_for_svalue2 (const svalue2 *sval,
-					  int i,
-					  auto_vec<path_var> *out) const
-{
-  return m_store.get_representative_path_vars (this, sval, out);
-
-#if 0
-  unsigned i;
-  region2 *region2;
-  FOR_EACH_VEC_ELT (m_region2s, i, region2)
-    if (sval == region2->get_value_direct ())
-      {
-	path_var pv = get_representative_path_var (sval);
-	if (pv.m_tree)
-	  out->safe_push (pv);
-      }
-#endif
-}
-#endif
-
-/* Set DST_REG value to be a new unknown value of type TYPE.  */
-#if 0
-svalue2_id
-region_model2::set_to_new_unknown_value (region2 *dst_reg, tree type,
-					region_model2_context *ctxt)
-{
-  gcc_assert (!dst_reg.null_p ());
-  const svalue2 *new_sval = add_svalue2 (new unknown_svalue2 (type));
-  set_value (dst_reg, new_sval, ctxt);
-
-  // TODO: presumably purge all child region2s too (but do this in set_value?)
-
-  return new_sval;
-}
-#endif
-
 /* Update this model for any phis in SNODE, assuming we came from
    LAST_CFG_SUPEREDGE.  */
 
 void
-region_model2::update_for_phis (const supernode *snode,
+region_model::update_for_phis (const supernode *snode,
 			       const cfg_superedge *last_cfg_superedge,
-			       region_model2_context *ctxt)
+			       region_model_context *ctxt)
 {
   gcc_assert (last_cfg_superedge);
 
@@ -7416,9 +6189,9 @@ region_model2::update_for_phis (const supernode *snode,
    than program state).  */
 
 bool
-region_model2::maybe_update_for_edge (const superedge &edge,
+region_model::maybe_update_for_edge (const superedge &edge,
 				      const gimple *last_stmt,
-				      region_model2_context *ctxt)
+				      region_model_context *ctxt)
 {
   /* Handle frame updates for interprocedural edges.  */
   switch (edge.m_kind)
@@ -7472,19 +6245,19 @@ region_model2::maybe_update_for_edge (const superedge &edge,
   return true;
 }
 
-/* Push a new frame_region2 on to the stack region2.
-   Populate the frame_region2 with child region2s for the function call's
+/* Push a new frame_region on to the stack region.
+   Populate the frame_region with child regions for the function call's
    parameters, using values from the arguments at the callsite in the
    caller's frame.  */
 
 void
-region_model2::update_for_call_superedge (const call_superedge &call_edge,
-					  region_model2_context *ctxt)
+region_model::update_for_call_superedge (const call_superedge &call_edge,
+					  region_model_context *ctxt)
 {
-  /* Build a vec of argument svalue2_id, using the current top
+  /* Build a vec of argument svalues, using the current top
      frame for resolving tree expressions.  */
   const gcall *call_stmt = call_edge.get_call_stmt ();
-  auto_vec<const svalue2 *> arg_svals (gimple_call_num_args (call_stmt));
+  auto_vec<const svalue *> arg_svals (gimple_call_num_args (call_stmt));
 
   for (unsigned i = 0; i < gimple_call_num_args (call_stmt); i++)
     {
@@ -7495,15 +6268,15 @@ region_model2::update_for_call_superedge (const call_superedge &call_edge,
   push_frame (call_edge.get_callee_function (), &arg_svals, ctxt);
 }
 
-/* Pop the top-most frame_region2 from the stack, and copy the return
-   region2's values (if any) into the region2 for the lvalue of the LHS of
+/* Pop the top-most frame_region from the stack, and copy the return
+   region's values (if any) into the region for the lvalue of the LHS of
    the call (if any).  */
 void
-region_model2::update_for_return_superedge (const return_superedge &return_edge,
-					    region_model2_context *ctxt)
+region_model::update_for_return_superedge (const return_superedge &return_edge,
+					    region_model_context *ctxt)
 {
-  /* Get the region2 for the result of the call, within the caller frame.  */
-  const region2 *result_dst_reg = NULL;
+  /* Get the region for the result of the call, within the caller frame.  */
+  const region *result_dst_reg = NULL;
   const gcall *call_stmt = return_edge.get_call_stmt ();
   tree lhs = gimple_call_lhs (call_stmt);
   if (lhs)
@@ -7516,7 +6289,7 @@ region_model2::update_for_return_superedge (const return_superedge &return_edge,
 				   ctxt);
     }
 
-  purge_stats2 stats;
+  purge_stats stats;
   pop_frame (result_dst_reg, true, &stats, NULL, ctxt);
 
   // TODO: do something with the stats?
@@ -7526,19 +6299,19 @@ region_model2::update_for_return_superedge (const return_superedge &return_edge,
     {
       /* This could be a leak; try purging again, but this time,
 	 don't special-case the result sids (as was done in pop_frame).  */
-      purge_unused_svalue2s (&stats, ctxt);
+      purge_unused_svalues (&stats, ctxt);
     }
 #endif
 }
-/* Update this region_model2 with a summary of the effect of calling
+/* Update this region_model with a summary of the effect of calling
    and returning from CG_SEDGE.
 
    TODO: Currently this is extremely simplistic: we merely set the
    return value to "unknown".  A proper implementation would e.g. update
    sm-state, and presumably be reworked to support multiple outcomes.  */
 void
-region_model2::update_for_call_summary (const callgraph_superedge &cg_sedge,
-					region_model2_context *ctxt)
+region_model::update_for_call_summary (const callgraph_superedge &cg_sedge,
+					region_model_context *ctxt)
 {
   /* For now, set any return value to "unknown".  */
   const gcall *call_stmt = cg_sedge.get_call_stmt ();
@@ -7558,9 +6331,9 @@ region_model2::update_for_call_summary (const callgraph_superedge &cg_sedge,
    (and so the edge should not be taken).  */
 
 bool
-region_model2::apply_constraints_for_gcond (const cfg_superedge &sedge,
+region_model::apply_constraints_for_gcond (const cfg_superedge &sedge,
 					    const gcond *cond_stmt,
-					    region_model2_context *ctxt)
+					    region_model_context *ctxt)
 {
   ::edge cfg_edge = sedge.get_cfg_edge ();
   gcc_assert (cfg_edge != NULL);
@@ -7583,9 +6356,9 @@ region_model2::apply_constraints_for_gcond (const cfg_superedge &sedge,
    (and so the edge should not be taken).  */
 
 bool
-region_model2::apply_constraints_for_gswitch (const switch_cfg_superedge &edge,
+region_model::apply_constraints_for_gswitch (const switch_cfg_superedge &edge,
 					      const gswitch *switch_stmt,
-					      region_model2_context *ctxt)
+					      region_model_context *ctxt)
 {
   tree index  = gimple_switch_index (switch_stmt);
   tree case_label = edge.get_case_label ();
@@ -7622,7 +6395,7 @@ region_model2::apply_constraints_for_gswitch (const switch_cfg_superedge &edge,
 	    {
 	      /* Exclude this range-valued case.
 		 For now, we just exclude the boundary values.
-		 TODO: exclude the values within the region2.  */
+		 TODO: exclude the values within the region.  */
 	      if (!add_constraint (index, NE_EXPR, other_lower_bound,
 				   ctxt))
 		return false;
@@ -7646,32 +6419,32 @@ region_model2::apply_constraints_for_gswitch (const switch_cfg_superedge &edge,
    the region.  */
 
 void
-region_model2::on_top_level_param (tree param,
-				   region_model2_context *ctxt)
+region_model::on_top_level_param (tree param,
+				   region_model_context *ctxt)
 {
   if (POINTER_TYPE_P (TREE_TYPE (param)))
     {
-      const region2 *param_reg = get_lvalue (param, ctxt);
-      const svalue2 *init_ptr_sval
+      const region *param_reg = get_lvalue (param, ctxt);
+      const svalue *init_ptr_sval
 	= m_mgr->get_or_create_initial_value (param_reg);
-      const region2 *pointee_reg = m_mgr->get_symbolic_region (init_ptr_sval);
+      const region *pointee_reg = m_mgr->get_symbolic_region (init_ptr_sval);
       m_store.mark_as_escaped (pointee_reg);
     }
 }
 
 // FIXME:
-/* Create a new frame_region2 for a call to FUN and push it onto
+/* Create a new frame_region for a call to FUN and push it onto
    the stack.
 
    If ARG_SVALS is non-NULL, use it to populate the parameters
    in the new frame.
    Otherwise, populate them with unknown values.
 
-   Return the new frame_region2.  */
+   Return the new frame_region.  */
 
-const region2 *
-region_model2::push_frame (function *fun, vec<const svalue2 *> *arg_svals,
-			   region_model2_context *ctxt)
+const region *
+region_model::push_frame (function *fun, vec<const svalue *> *arg_svals,
+			   region_model_context *ctxt)
 {
   m_current_frame = m_mgr->get_frame_region (m_current_frame, fun);
   if (arg_svals)
@@ -7687,15 +6460,15 @@ region_model2::push_frame (function *fun, vec<const svalue2 *> *arg_svals,
 	     rest of the params as uninitialized.  */
 	  if (idx >= arg_svals->length ())
 	    break;
-	  const svalue2 *arg_sval = (*arg_svals)[idx];
-	  const region2 *parm_reg = get_lvalue (iter_parm, ctxt);
+	  const svalue *arg_sval = (*arg_svals)[idx];
+	  const region *parm_reg = get_lvalue (iter_parm, ctxt);
 	  set_value (parm_reg, arg_sval, ctxt);
 
 	  /* Also do it for default SSA name (sharing the same value).  */
 	  tree parm_default_ssa = ssa_default_def (fun, iter_parm);
 	  if (parm_default_ssa)
 	    {
-	      const region2 *defssa_reg = get_lvalue (parm_default_ssa, ctxt);
+	      const region *defssa_reg = get_lvalue (parm_default_ssa, ctxt);
 	      set_value (defssa_reg, arg_sval, ctxt);
 	    }
 	}
@@ -7721,18 +6494,18 @@ region_model2::push_frame (function *fun, vec<const svalue2 *> *arg_svals,
   return m_current_frame;
 }
 
-/* Get the function of the top-most frame in this region_model2's stack.
+/* Get the function of the top-most frame in this region_model's stack.
    There must be such a frame.  */
 
 function *
-region_model2::get_current_function () const
+region_model::get_current_function () const
 {
-  const frame_region2 *frame = get_current_frame ();
+  const frame_region *frame = get_current_frame ();
   gcc_assert (frame);
   return frame->get_function ();
 }
 
-/* Pop the topmost frame_region2 from this region_model2's stack;
+/* Pop the topmost frame_region from this region_model's stack;
 
    FIXME:
    If RESULT_DST_RID is non-null, copy any return value from the frame
@@ -7751,17 +6524,17 @@ region_model2::get_current_function () const
    Accumulate stats on purged entities into STATS.  */
 
 void
-region_model2::pop_frame (const region2 *result_dst_reg,
-			  bool purge, purge_stats2 *out,
-			  const svalue2 **out_result,
-			  region_model2_context *ctxt)
+region_model::pop_frame (const region *result_dst_reg,
+			  bool purge, purge_stats *out,
+			  const svalue **out_result,
+			  region_model_context *ctxt)
 {
   gcc_assert (m_current_frame);
 
   /* Evaluate the result, within the callee frame.  */
-  const frame_region2 *frame_reg = m_current_frame;
+  const frame_region *frame_reg = m_current_frame;
 #if 0
-  svalue2_id_set returned_svals;
+  svalue_id_set returned_svals;
 #endif
   tree fndecl = m_current_frame->get_function ()->decl;
   tree result = DECL_RESULT (fndecl);
@@ -7780,17 +6553,17 @@ region_model2::pop_frame (const region2 *result_dst_reg,
 	{
 #if 0
 	  /* Populate returned_svals, to avoid purging them.  */
-	  region2_id return_reg = model->get_lvalue (result, NULL);
-	  region2_id_set returned_regs (model);
+	  region_id return_reg = model->get_lvalue (result, NULL);
+	  region_id_set returned_regs (model);
 	  model->get_descendents (return_reg, &returned_regs,
-				  region2_id::null ());
-	  for (unsigned i = 0; i < model->get_num_region2s (); i++)
+				  region_id::null ());
+	  for (unsigned i = 0; i < model->get_num_regions (); i++)
 	    {
-	      region2_id rid = region2_id::from_int (i);
-	      if (returned_regs.region2_p (rid))
+	      region_id rid = region_id::from_int (i);
+	      if (returned_regs.region_p (rid))
 		{
-		  const svalue2 *sval = model->get_region2 (rid)->get_value_direct ();
-		  returned_svals.add_svalue2 (sid);
+		  const svalue *sval = model->get_region (rid)->get_value_direct ();
+		  returned_svals.add_svalue (sid);
 		}
 	    }
 #endif
@@ -7801,26 +6574,26 @@ region_model2::pop_frame (const region2 *result_dst_reg,
   m_current_frame = m_current_frame->get_calling_frame ();
 
 #if 1
-  unbind_region2_and_descendents (frame_reg,
+  unbind_region_and_descendents (frame_reg,
 				  POISON_KIND_POPPED_STACK,
 				  out,
 				  ctxt ? ctxt->get_logger () : NULL);
 #endif
 
-  /* Delete unused svalue2s, but don't delete the return value(s).  */
+  /* Delete unused svalues, but don't delete the return value(s).  */
 #if 0
   if (purge)
-    purge_unused_svalue2s (out, ctxt, &returned_svals);
+    purge_unused_svalues (out, ctxt, &returned_svals);
 #endif
 }
 
 
-/* Get the number of frames in this region_model2's stack.  */
+/* Get the number of frames in this region_model's stack.  */
 
 int
-region_model2::get_stack_depth () const
+region_model::get_stack_depth () const
 {
-  const frame_region2 *frame = get_current_frame ();
+  const frame_region *frame = get_current_frame ();
   if (frame)
     return frame->get_stack_depth ();
   else
@@ -7829,10 +6602,10 @@ region_model2::get_stack_depth () const
 
 /* FIXME.  */
 
-const frame_region2 *
-region_model2::get_frame_at_index (int index) const
+const frame_region *
+region_model::get_frame_at_index (int index) const
 {
-  const frame_region2 *frame = get_current_frame ();
+  const frame_region *frame = get_current_frame ();
   if (frame)
     {
       gcc_assert (index >= 0);
@@ -7851,45 +6624,45 @@ region_model2::get_frame_at_index (int index) const
 /* Get the function * at DEPTH within the call stack.  */
 #if 0
 function *
-region_model2::get_function_at_depth (unsigned depth) const
+region_model::get_function_at_depth (unsigned depth) const
 {
-  stack_region2 *stack = get_root_region2 ()->get_stack_region2 (this);
+  stack_region *stack = get_root_region ()->get_stack_region (this);
   gcc_assert (stack);
-  region2 *frame_reg = stack->get_frame_reg (depth);
-  frame_region2 *frame = get_region2 <frame_region2> (frame_reg);
+  region *frame_reg = stack->get_frame_reg (depth);
+  frame_region *frame = get_region <frame_region> (frame_reg);
   return frame->get_function ();
 }
 #endif
 
 /* Change the meaning of SID to be NEW_SVAL
    (e.g. when deferencing an unknown pointer, the pointer
-   becomes a pointer to a symbolic region2, so that all users
+   becomes a pointer to a symbolic region, so that all users
    of the former unknown pointer are now effectively pointing
-   at the same region2).  */
+   at the same region).  */
 #if 0
 void
-region_model2::replace_svalue2 (const svalue2 *sval, const svalue2 *new_sval)
+region_model::replace_svalue (const svalue *sval, const svalue *new_sval)
 {
   gcc_assert (!sid.null_p ());
   int idx = sid.as_int ();
 
-  gcc_assert (m_svalue2s[idx]);
-  gcc_assert (m_svalue2s[idx]->get_type () == new_sval->get_type ());
-  delete m_svalue2s[idx];
+  gcc_assert (m_svalues[idx]);
+  gcc_assert (m_svalues[idx]->get_type () == new_sval->get_type ());
+  delete m_svalues[idx];
 
-  m_svalue2s[idx] = new_sval;
+  m_svalues[idx] = new_sval;
 }
 #endif
 
-/* Helper class for region_model2::purge_unused_svalue2s.  */
+/* Helper class for region_model::purge_unused_svalues.  */
 
 #if 0
-class restrict_to_used_svalue2s : public purge_criteria
+class restrict_to_used_svalues : public purge_criteria
 {
 public:
-  restrict_to_used_svalue2s (const auto_sbitmap &used) : m_used (used) {}
+  restrict_to_used_svalues (const auto_sbitmap &used) : m_used (used) {}
 
-  bool should_purge_p (const svalue2 *sval) const FINAL OVERRIDE
+  bool should_purge_p (const svalue *sval) const FINAL OVERRIDE
   {
     gcc_assert (!sid.null_p ());
     return !bitmap_bit_p (m_used, sid.as_int ());
@@ -7899,17 +6672,17 @@ private:
   const auto_sbitmap &m_used;
 };
 
-/* Remove unused svalue2s from this model, accumulating stats into STATS.
-   Unused svalue2s are deleted.  Doing so could reorder the svalue2s, and
-   thus change the meaning of svalue2_ids.
+/* Remove unused svalues from this model, accumulating stats into STATS.
+   Unused svalues are deleted.  Doing so could reorder the svalues, and
+   thus change the meaning of svalue_ids.
 
-   If CTXT is non-NULL, then it is notified about svalue2 *remappings,
-   and about svalue2_ids that are about to be deleted.  This allows e.g.
-   for warning about resource leaks, for the case where the svalue2
+   If CTXT is non-NULL, then it is notified about svalue *remappings,
+   and about svalue_ids that are about to be deleted.  This allows e.g.
+   for warning about resource leaks, for the case where the svalue
    represents a resource handle in the user code (e.g. a FILE * or a malloc
    buffer).
 
-   Amongst other things, removing unused svalue2s is important for ensuring
+   Amongst other things, removing unused svalues is important for ensuring
    that the analysis of loops terminates.  Otherwise, we could generate a
    succession of models with unreferenced "unknown" values, where the
    number of redundant unknown values could grow without bounds, and each
@@ -7921,43 +6694,43 @@ private:
    of the return expr in the callee frame and the lvalue for the gcall's
    assignment in the caller frame, and it seems cleaner to express all
    lvalue and rvalue lookups implicitly relative to a "current" frame).
-   The svalue2_ids in *KNOWN_USED_SVALS are not remapped and hence this
+   The svalue_ids in *KNOWN_USED_SVALS are not remapped and hence this
    call makes it invalid.  */
 
 void
-region_model2::purge_unused_svalue2s (purge_stats *stats,
-				    region_model2_context *ctxt,
-				    svalue2_id_set *known_used_svals)
+region_model::purge_unused_svalues (purge_stats *stats,
+				    region_model_context *ctxt,
+				    svalue_id_set *known_used_svals)
 {
   // TODO: might want to avoid a vfunc call just to do logging here:
   logger *logger = ctxt ? ctxt->get_logger () : NULL;
 
   LOG_SCOPE (logger);
 
-  auto_sbitmap used (m_svalue2s.length ());
+  auto_sbitmap used (m_svalues.length ());
   bitmap_clear (used);
 
   if (known_used_svals)
     {
       /* We can't use an sbitmap for known_used_svals as the number of
-	 svalue2s could have grown since it was created.  */
-      for (unsigned i = 0; i < get_num_svalue2s (); i++)
-	if (known_used_svals->svalue2_p (svalue2_id::from_int (i)))
+	 svalues could have grown since it was created.  */
+      for (unsigned i = 0; i < get_num_svalues (); i++)
+	if (known_used_svals->svalue_p (svalue_id::from_int (i)))
 	  bitmap_set_bit (used, i);
     }
 
-  /* Walk the region2s, marking sids that are used.  */
+  /* Walk the regions, marking sids that are used.  */
   unsigned i;
-  region2 *r;
-  FOR_EACH_VEC_ELT (m_region2s, i, r)
+  region *r;
+  FOR_EACH_VEC_ELT (m_regions, i, r)
     {
-      const svalue2 *sval = r->get_value_direct ();
+      const svalue *sval = r->get_value_direct ();
       if (!sid.null_p ())
 	bitmap_set_bit (used, sid.as_int ());
     }
 
-  /* Now purge any constraints involving svalue2s we don't care about.  */
-  restrict_to_used_svalue2s criterion (used);
+  /* Now purge any constraints involving svalues we don't care about.  */
+  restrict_to_used_svalues criterion (used);
   m_constraints->purge (criterion, stats);
 
   /* Mark any sids that are in constraints that survived.  */
@@ -7966,7 +6739,7 @@ region_model2::purge_unused_svalue2s (purge_stats *stats,
     FOR_EACH_VEC_ELT (m_constraints->m_equiv_classes, i, ec)
       {
 	int j;
-	const svalue2 **sid;
+	const svalue **sid;
 	FOR_EACH_VEC_ELT (ec->m_vars, j, sid)
 	  {
 	    gcc_assert (!sid->null_p ());
@@ -7977,33 +6750,33 @@ region_model2::purge_unused_svalue2s (purge_stats *stats,
 
   /* Build a mapping from old-sid to new-sid so that we can preserve
      order of the used IDs and move all redundant ones to the end.
-     Iterate though svalue2 IDs, adding used ones to the front of
+     Iterate though svalue IDs, adding used ones to the front of
      the new list, and unused ones to the back.  */
-  svalue2_id_map map (m_svalue2s.length ());
+  svalue_id_map map (m_svalues.length ());
   int next_used_new_sval = 0;
-  int after_next_unused_new_sval = m_svalue2s.length ();
-  for (unsigned i = 0; i < m_svalue2s.length (); i++)
+  int after_next_unused_new_sval = m_svalues.length ();
+  for (unsigned i = 0; i < m_svalues.length (); i++)
     {
-      const svalue2 *src (svalue2_id::from_int (i));
+      const svalue *src (svalue_id::from_int (i));
       if (bitmap_bit_p (used, i))
 	{
 	  if (logger)
 	    logger->log ("sv%i is used", i);
-	  map.put (src, svalue2_id::from_int (next_used_new_sval++));
+	  map.put (src, svalue_id::from_int (next_used_new_sval++));
 	}
       else
 	{
 	  if (logger)
 	    logger->log ("sv%i is unused", i);
-	  map.put (src, svalue2_id::from_int (--after_next_unused_new_sval));
+	  map.put (src, svalue_id::from_int (--after_next_unused_new_sval));
 	}
     }
   /* The two insertion points should have met.  */
   gcc_assert (next_used_new_sval == after_next_unused_new_sval);
 
-  /* Now walk the region2s and the constraints, remapping sids,
-     so that all the redundant svalue2s are at the end.  */
-  remap_svalue2_ids (map);
+  /* Now walk the regions and the constraints, remapping sids,
+     so that all the redundant svalues are at the end.  */
+  remap_svalue_ids (map);
 
   if (logger)
     {
@@ -8017,71 +6790,71 @@ region_model2::purge_unused_svalue2s (purge_stats *stats,
      Potentially this could trigger leak warnings.  */
   if (ctxt)
     {
-      ctxt->remap_svalue2_ids (map);
+      ctxt->remap_svalue_ids (map);
       int num_client_items_purged
-	= ctxt->on_svalue2_purge (svalue2_id::from_int (next_used_new_sval), map);
+	= ctxt->on_svalue_purge (svalue_id::from_int (next_used_new_sval), map);
       if (stats)
 	stats->m_num_client_items += num_client_items_purged;
     }
 
-  /* Drop the redundant svalue2s from the end of the vector.  */
-  while ((signed)m_svalue2s.length () > next_used_new_sval)
+  /* Drop the redundant svalues from the end of the vector.  */
+  while ((signed)m_svalues.length () > next_used_new_sval)
     {
       if (logger)
 	{
-	  const svalue2 *victim = svalue2_id::from_int (m_svalue2s.length () - 1);
+	  const svalue *victim = svalue_id::from_int (m_svalues.length () - 1);
 	  logger->log ("deleting sv%i (was sv%i)",
 		       victim.as_int (),
 		       map.get_src_for_dst (victim).as_int ());
 	}
-      delete m_svalue2s.pop ();
+      delete m_svalues.pop ();
       if (stats)
-	stats->m_num_svalue2s++;
+	stats->m_num_svalues++;
     }
 
   validate ();
 }
 #endif
 
-/* Delete all region2s within SET_TO_PURGE, remapping region2 IDs for
-   other region2s.  It's required that there are no uses of the
-   region2s within the set (or the region2 IDs will become invalid).
+/* Delete all regions within SET_TO_PURGE, remapping region IDs for
+   other regions.  It's required that there are no uses of the
+   regions within the set (or the region IDs will become invalid).
 
    Accumulate stats to STATS.  */
 #if 0
 void
-region_model2::purge_region2s (const region2_id_set &set_to_purge,
+region_model::purge_regions (const region_id_set &set_to_purge,
 			     purge_stats *stats,
 			     logger *)
 {
   /* Build a mapping from old-rid to new-rid so that we can preserve
      order of the used IDs and move all redundant ones to the end.
-     Iterate though region2 IDs, adding used ones to the front of
+     Iterate though region IDs, adding used ones to the front of
      the new list, and unused ones to the back.  */
-  region2_id_map map (m_region2s.length ());
+  region_id_map map (m_regions.length ());
   int next_used_new_reg = 0;
-  int after_next_unused_new_reg = m_region2s.length ();
-  for (unsigned i = 0; i < m_region2s.length (); i++)
+  int after_next_unused_new_reg = m_regions.length ();
+  for (unsigned i = 0; i < m_regions.length (); i++)
     {
-      region2 *src (region2_id::from_int (i));
-      if (set_to_purge.region2_p (src))
-	map.put (src, region2_id::from_int (--after_next_unused_new_reg));
+      region *src (region_id::from_int (i));
+      if (set_to_purge.region_p (src))
+	map.put (src, region_id::from_int (--after_next_unused_new_reg));
       else
-	map.put (src, region2_id::from_int (next_used_new_reg++));
+	map.put (src, region_id::from_int (next_used_new_reg++));
     }
   /* The two insertion points should have met.  */
   gcc_assert (next_used_new_reg == after_next_unused_new_reg);
 
-  /* Now walk the region2s and svalue2s, remapping rids,
-     so that all the redundant region2s are at the end.  */
-  remap_region2_ids (map);
+  /* Now walk the regions and svalues, remapping rids,
+     so that all the redundant regions are at the end.  */
+  remap_region_ids (map);
 
-  /* Drop the redundant region2s from the end of the vector.  */
-  while ((signed)m_region2s.length () > next_used_new_reg)
+  /* Drop the redundant regions from the end of the vector.  */
+  while ((signed)m_regions.length () > next_used_new_reg)
     {
-      delete m_region2s.pop ();
+      delete m_regions.pop ();
       if (stats)
-	stats->m_num_region2s++;
+	stats->m_num_regions++;
     }
 }
 #endif
@@ -8089,29 +6862,29 @@ region_model2::purge_region2s (const region2_id_set &set_to_purge,
    If EXCLUDE_REG is non-null, then don't add it or its descendents.  */
 #if 0
 void
-region_model2::get_descendents (region2 *reg, region2_id_set *out,
-			       region2 *exclude_reg) const
+region_model::get_descendents (region *reg, region_id_set *out,
+			       region *exclude_reg) const
 {
-  out->add_region2 (rid);
+  out->add_region (rid);
 
   bool changed = true;
   while (changed)
     {
       changed = false;
       unsigned i;
-      region2 *r;
-      FOR_EACH_VEC_ELT (m_region2s, i, r)
+      region *r;
+      FOR_EACH_VEC_ELT (m_regions, i, r)
 	{
-	  region2 *iter_reg = region2_id::from_int (i);
+	  region *iter_reg = region_id::from_int (i);
 	  if (iter_reg == exclude_reg)
 	    continue;
-	  if (!out->region2_p (iter_reg))
+	  if (!out->region_p (iter_reg))
 	    {
-	      region2 *parent_reg = r->get_parent ();
+	      region *parent_reg = r->get_parent ();
 	      if (!parent_reg.null_p ())
-		if (out->region2_p (parent_reg))
+		if (out->region_p (parent_reg))
 		  {
-		    out->add_region2 (iter_reg);
+		    out->add_region (iter_reg);
 		    changed = true;
 		  }
 	    }
@@ -8121,27 +6894,27 @@ region_model2::get_descendents (region2 *reg, region2_id_set *out,
 #endif
 
 // FIXME
-/* Delete RID and all descendent region2s.
-   Find any pointers to such region2s; convert them to
+/* Delete RID and all descendent regions.
+   Find any pointers to such regions; convert them to
    poisoned values of kind PKIND.
    Accumulate stats on purged entities into STATS.  */
 
 void
-region_model2::unbind_region2_and_descendents (const region2 *reg,
+region_model::unbind_region_and_descendents (const region *reg,
 					       enum poison_kind pkind,
-					       purge_stats2 *stats,
+					       purge_stats *stats,
 					       logger *logger)
 {
   /* Gather a set of base regions to be unbound.  */
-  hash_set<const region2 *> base_regs;
+  hash_set<const region *> base_regs;
   for (store::cluster_map_t::iterator iter = m_store.begin ();
        iter != m_store.end (); ++iter)
     {
-      const region2 *iter_base_reg = (*iter).first;
+      const region *iter_base_reg = (*iter).first;
       if (iter_base_reg->descendent_of_p (reg))
 	base_regs.add (iter_base_reg);
     }
-  for (hash_set<const region2 *>::iterator iter = base_regs.begin ();
+  for (hash_set<const region *>::iterator iter = base_regs.begin ();
        iter != base_regs.end (); ++iter)
     m_store.purge_cluster (*iter);
 
@@ -8155,32 +6928,32 @@ region_model2::unbind_region2_and_descendents (const region2 *reg,
 
 struct bad_pointer_finder
 {
-  bad_pointer_finder (const region2 *reg, enum poison_kind pkind,
-		      region_model2_manager *mgr)
+  bad_pointer_finder (const region *reg, enum poison_kind pkind,
+		      region_model_manager *mgr)
   : m_reg (reg), m_pkind (pkind), m_mgr (mgr), m_count (0)
   {}
 
-  void on_binding (const binding_key *key, const svalue2 *&sval)
+  void on_binding (const binding_key *key, const svalue *&sval)
   {
-    if (const region_svalue2 *ptr_sval = sval->dyn_cast_region_svalue2 ())
+    if (const region_svalue *ptr_sval = sval->dyn_cast_region_svalue ())
       {
-	const region2 *ptr_dst = ptr_sval->get_pointee ();
+	const region *ptr_dst = ptr_sval->get_pointee ();
 	/* Poison ptrs to descendents of REG, but not to REG itself,
 	   otherwise double-free detection doesn't work (since sm-state
 	   for "free" is stored on the original ptr svalue).  */
 	if (ptr_dst->descendent_of_p (m_reg)
 	    && ptr_dst != m_reg)
 	  {
-	    sval = m_mgr->get_or_create_poisoned_svalue2 (m_pkind,
+	    sval = m_mgr->get_or_create_poisoned_svalue (m_pkind,
 							  sval->get_type ());
 	    ++m_count;
 	  }
       }
   }
 
-  const region2 *m_reg;
+  const region *m_reg;
   enum poison_kind m_pkind;
-  region_model2_manager *const m_mgr;
+  region_model_manager *const m_mgr;
   int m_count;
 };
 
@@ -8190,7 +6963,7 @@ struct bad_pointer_finder
 // FIXME: ^^ unit test for this?
 
 int
-region_model2::poison_any_pointers_to_descendents (const region2 *reg,
+region_model::poison_any_pointers_to_descendents (const region *reg,
 						   enum poison_kind pkind)
 {
   bad_pointer_finder bv (reg, pkind, m_mgr);
@@ -8203,9 +6976,9 @@ region_model2::poison_any_pointers_to_descendents (const region2 *reg,
    FIXME: POINT  */
 
 bool
-region_model2::can_merge_with_p (const region_model2 &other_model,
+region_model::can_merge_with_p (const region_model &other_model,
 				 const program_point &point,
-				 region_model2 *out_model) const
+				 region_model *out_model) const
 {
   gcc_assert (out_model);
   gcc_assert (m_mgr == other_model.m_mgr);
@@ -8215,7 +6988,7 @@ region_model2::can_merge_with_p (const region_model2 &other_model,
     return false;
   out_model->m_current_frame = m_current_frame;
 
-  model2_merger m (this, &other_model, point, out_model);
+  model_merger m (this, &other_model, point, out_model);
 
   if (!store::can_merge_p (&m_store, &other_model.m_store,
 			   &out_model->m_store, m_mgr->get_store_manager (),
@@ -8223,222 +6996,30 @@ region_model2::can_merge_with_p (const region_model2 &other_model,
     return false;
 
   /* Merge constraints.  */
-  constraint_manager2::merge (*m_constraints2,
-			      *other_model.m_constraints2,
-			      out_model->m_constraints2,
+  constraint_manager::merge (*m_constraints,
+			      *other_model.m_constraints,
+			      out_model->m_constraints,
 			      m);
 
   return true;
 }
 
-/* For debugging purposes: look for a region2 within this region_model2
-   for a decl named NAME (or an SSA_NAME for such a decl),
-   returning its value, or svalue2_id::null if none are found.  */
-#if 0
-svalue2_id
-region_model2::get_value_by_name (const char *name) const
-{
-  gcc_assert (name);
-  tree identifier = get_identifier (name);
-  return get_root_region2 ()->get_value_by_name (identifier, *this);
-}
-#endif
-/* Generate or reuse an svalue2 *within this model for an index
-   into an array of type PTR_TYPE, based on OFFSET_SVAL.  */
-#if 0
-svalue2_id
-region_model2::convert_byte_offset_to_array_index (tree ptr_type,
-						  svalue2 *offset_sval)
-{
-  gcc_assert (POINTER_TYPE_P (ptr_type));
-
-  if (tree offset_cst = maybe_get_constant (offset_sval))
-    {
-      tree elem_type = TREE_TYPE (ptr_type);
-
-      /* Arithmetic on void-pointers is a GNU C extension, treating the size
-	 of a void as 1.
-	 https://gcc.gnu.org/onlinedocs/gcc/Pointer-Arith.html  */
-      if (TREE_CODE (elem_type) == VOID_TYPE)
-	return offset_sval;
-
-      /* First, use int_size_in_bytes, to reject the case where we have an
-	 incomplete type, or a non-constant value.  */
-      HOST_WIDE_INT hwi_byte_size = int_size_in_bytes (elem_type);
-      if (hwi_byte_size > 0)
-	{
-	  /* Now call size_in_bytes to get the answer in tree form.  */
-	  tree byte_size = size_in_bytes (elem_type);
-	  gcc_assert (byte_size);
-	  /* Try to get a constant by dividing, ensuring that we're in a
-	     signed representation first.  */
-	  tree index
-	    = fold_binary (TRUNC_DIV_EXPR, ssizetype,
-			   fold_convert (ssizetype, offset_cst),
-			   fold_convert (ssizetype, byte_size));
-	  if (index && TREE_CODE (index) == INTEGER_CST)
-	    return get_or_create_constant_svalue2 (index);
-	}
-    }
-
-  /* Otherwise, we don't know the array index; generate a new unknown value.
-     TODO: do we need to capture the relationship between two unknown
-     values (the offset and the index)?  */
-  return add_svalue2 (new unknown_svalue2 (integer_type_node));
-}
-
-/* Get a region2 of type TYPE for PTR_SVAL[OFFSET_SVAL/sizeof (*PTR_SVAL)].
-
-   If OFFSET_SVAL is known to be zero, then dereference PTR_SVAL.
-   Otherwise, impose a view of "typeof(*PTR_SVAL)[]" on *PTR_SVAL,
-   and then get a view of type TYPE on the relevant array element.  */
-
-region2_id
-region_model2::get_or_create_mem_ref (tree type,
-				     const svalue2 *ptr_sval,
-				     const svalue2 *offset_sval,
-				     region_model2_context *ctxt)
-{
-  const svalue2 *ptr_sval = get_svalue2 (ptr_sval);
-  tree ptr_type = ptr_sval->get_type ();
-  gcc_assert (ptr_type);
-
-  region2 *raw_reg = deref_rvalue (ptr_sval, ctxt);
-
-  const svalue2 *offset_sval = get_svalue2 (offset_sval);
-  tree offset_type = offset_sval->get_type ();
-  gcc_assert (offset_type);
-
-  if (constant_svalue2 *cst_sval = offset_sval->dyn_cast_constant_svalue2 ())
-    {
-      if (zerop (cst_sval->get_constant ()))
-	{
-	  /* Handle the zero offset case.  */
-	  return get_or_create_view (raw_reg, type, ctxt);
-	}
-
-      /* If we're already within an array of the correct type,
-	 then we want to reuse that array, rather than starting
-	 a new view.
-	 If so, figure out our raw_reg's offset from its parent,
-	 if we can, and use that to offset OFFSET_SVAL, and create
-	 the element within the parent region2.  */
-      region2 *raw_reg = get_region2 (raw_reg);
-      region2 *parent_reg = raw_reg->get_parent ();
-      tree parent_type = get_region2 (parent_reg)->get_type ();
-      if (parent_type
-	  && TREE_CODE (parent_type) == ARRAY_TYPE)
-	{
-	  // TODO: check we have the correct parent type
-	  array_region2 *parent_array = get_region2 <array_region2> (parent_reg);
-	  array_region2::key_t key_for_raw_reg;
-	  if (parent_array->get_key_for_child_region2 (raw_reg,
-						      &key_for_raw_reg))
-	    {
-	      /* Convert from offset to index.  */
-	      const svalue2 *index_sval
-		= convert_byte_offset_to_array_index (ptr_type, offset_sval);
-	      if (tree index_cst
-		    = get_svalue2 (index_sval)->maybe_get_constant ())
-		{
-		  array_region2::key_t index_offset
-		    = array_region2::key_from_constant (index_cst);
-		  array_region2::key_t index_rel_to_parent
-		    = key_for_raw_reg + index_offset;
-		  tree index_rel_to_parent_cst
-		    = wide_int_to_tree (integer_type_node,
-					index_rel_to_parent);
-		  const svalue2 *index_sval
-		    = get_or_create_constant_svalue2 (index_rel_to_parent_cst);
-
-		  /* Carry on, using the parent region2 and adjusted index.  */
-		  region2 *element_reg
-		    = parent_array->get_element (this, raw_reg, index_sval,
-						 ctxt);
-		  return get_or_create_view (element_reg, type, ctxt);
-		}
-	    }
-	}
-    }
-
-  tree array_type = build_array_type (TREE_TYPE (ptr_type),
-				      integer_type_node);
-  region2 *array_view_reg = get_or_create_view (raw_reg, array_type, ctxt);
-  array_region2 *array_reg = get_region2 <array_region2> (array_view_reg);
-
-  const svalue2 *index_sval
-    = convert_byte_offset_to_array_index (ptr_type, offset_sval);
-
-  region2 *element_reg
-    = array_reg->get_element (this, array_view_reg, index_sval, ctxt);
-
-  return get_or_create_view (element_reg, type, ctxt);
-}
-
-/* Get a region2 of type TYPE for PTR_SVAL + OFFSET_SVAL.
-
-   If OFFSET_SVAL is known to be zero, then dereference PTR_SVAL.
-   Otherwise, impose a view of "typeof(*PTR_SVAL)[]" on *PTR_SVAL,
-   and then get a view of type TYPE on the relevant array element.  */
-
-region2_id
-region_model2::get_or_create_pointer_plus_expr (tree type,
-					       const svalue2 *ptr_sval,
-					       const svalue2 *offset_in_bytes_sval,
-					       region_model2_context *ctxt)
-{
-  return get_or_create_mem_ref (type,
-				ptr_sval,
-				offset_in_bytes_sval,
-				ctxt);
-}
-
-/* Get or create a view of type TYPE of the region2 with id RAW_ID.
-   Return the id of the view (or RAW *if it of the same type).  */
-
-region2_id
-region_model2::get_or_create_view (region2 *raw_reg, tree type,
-				  region_model2_context *ctxt)
-{
-  region2 *raw_region2 = get_region2 (raw_reg);
-
-  gcc_assert (TYPE_P (type));
-  if (type != raw_region2->get_type ())
-    {
-      /* If the region2 already has a view of the requested type,
-	 reuse it.  */
-      region2 *existing_view_reg = raw_region2->get_view (type, this);
-      if (!existing_view_reg.null_p ())
-	return existing_view_reg;
-
-      /* Otherwise, make one (adding it to the region_model2 and
-	 to the viewed region2).  */
-      region2 *view_reg = add_region2_for_type (raw_reg, type, ctxt);
-      raw_region2->add_view (view_reg, this);
-      // TODO: something to signify that this is a "view"
-      return view_reg;
-    }
-
-  return raw_reg;
-}
-#endif
-
 /* Attempt to get the fndecl used at CALL, if known, or NULL_TREE
    otherwise.  */
 
 tree
-region_model2::get_fndecl_for_call (const gcall *call,
-				    region_model2_context *ctxt)
+region_model::get_fndecl_for_call (const gcall *call,
+				    region_model_context *ctxt)
 {
   tree fn_ptr = gimple_call_fn (call);
   if (fn_ptr == NULL_TREE)
     return NULL_TREE;
-  const svalue2 *fn_ptr_sval = get_rvalue (fn_ptr, ctxt);
-  if (const region_svalue2 *fn_ptr_ptr
-	= fn_ptr_sval->dyn_cast_region_svalue2 ())
+  const svalue *fn_ptr_sval = get_rvalue (fn_ptr, ctxt);
+  if (const region_svalue *fn_ptr_ptr
+	= fn_ptr_sval->dyn_cast_region_svalue ())
     {
-      const region2 *reg = fn_ptr_ptr->get_pointee ();
-      if (const function_region2 *fn_reg = reg->dyn_cast_function_region2 ())
+      const region *reg = fn_ptr_ptr->get_pointee ();
+      if (const function_region *fn_reg = reg->dyn_cast_function_region ())
 	{
 	  tree fn_decl = fn_reg->get_fndecl ();
 	  cgraph_node *node = cgraph_node::get (fn_decl);
@@ -8457,15 +7038,15 @@ region_model2::get_fndecl_for_call (const gcall *call,
 
 struct append_ssa_names_cb_data
 {
-  const region_model2 *model;
-  auto_vec<const decl_region2 *> *out;
+  const region_model *model;
+  auto_vec<const decl_region *> *out;
 };
 
 /* FIXME.  */
 
 void
-region_model2::
-get_ssa_name_regions_for_current_frame (auto_vec<const decl_region2 *> *out)
+region_model::
+get_ssa_name_regions_for_current_frame (auto_vec<const decl_region *> *out)
   const
 {
   append_ssa_names_cb_data data;
@@ -8477,12 +7058,12 @@ get_ssa_name_regions_for_current_frame (auto_vec<const decl_region2 *> *out)
 /* FIXME.  */
 
 void
-region_model2::append_ssa_names_cb (const region2 *base_reg,
+region_model::append_ssa_names_cb (const region *base_reg,
 				    append_ssa_names_cb_data *cb_data)
 {
   if (base_reg->get_parent_region () != cb_data->model->m_current_frame)
     return;
-  if (const decl_region2 *decl_reg = base_reg->dyn_cast_decl_region2 ())
+  if (const decl_region *decl_reg = base_reg->dyn_cast_decl_region ())
     {
       if (TREE_CODE (decl_reg->get_decl ()) == SSA_NAME)
 	cb_data->out->safe_push (decl_reg);
@@ -8491,20 +7072,20 @@ region_model2::append_ssa_names_cb (const region2 *base_reg,
 
 /* FIXME.  */
 
-const region2 *
-region_model2::create_region_for_heap_alloc (const svalue2 *size_in_bytes)
+const region *
+region_model::create_region_for_heap_alloc (const svalue *size_in_bytes)
 {
-  const region2 *reg = m_mgr->create_region_for_heap_alloc ();
+  const region *reg = m_mgr->create_region_for_heap_alloc ();
   record_dynamic_extents (reg, size_in_bytes);
   return reg;
 }
 
 /* FIXME.  */
 
-const region2 *
-region_model2::create_region_for_alloca (const svalue2 *size_in_bytes)
+const region *
+region_model::create_region_for_alloca (const svalue *size_in_bytes)
 {
-  const region2 *reg = m_mgr->create_region_for_alloca (m_current_frame);
+  const region *reg = m_mgr->create_region_for_alloca (m_current_frame);
   record_dynamic_extents (reg, size_in_bytes);
   return reg;
 }
@@ -8512,14 +7093,14 @@ region_model2::create_region_for_alloca (const svalue2 *size_in_bytes)
 /* FIXME.  */
 
 void
-region_model2::record_dynamic_extents (const region2 *reg,
-				       const svalue2 *size_in_bytes)
+region_model::record_dynamic_extents (const region *reg,
+				       const svalue *size_in_bytes)
 {
 #if 0
-  const svalue2 *extents_sval = m_mgr->get_or_create_extents_svalue2 (reg);
+  const svalue *extents_sval = m_mgr->get_or_create_extents_svalue (reg);
   add_constraint (extents_sval, EQ_EXPR, size_in_bytes);
   /* TODO: This needs the ability to add constraints in the model based on an
-     svalue2.  */
+     svalue.  */
   /* TODO: should be capture where we got the extents from?  (so that we can
      display that to the user)  Perhaps we can just walk backwards along
      the exploded_path to find where the constraint was added.  */
@@ -8528,12 +7109,12 @@ region_model2::record_dynamic_extents (const region2 *reg,
 #endif
 }
 
-/* struct model2_merger.  */
+/* struct model_merger.  */
 
 /* Dump a multiline representation of this merger to PP.  */
 
 void
-model2_merger::dump_to_pp (pretty_printer *pp, bool simple) const
+model_merger::dump_to_pp (pretty_printer *pp, bool simple) const
 {
   pp_string (pp, "model A:");
   pp_newline (pp);
@@ -8554,7 +7135,7 @@ model2_merger::dump_to_pp (pretty_printer *pp, bool simple) const
   pp_string (pp, "iterated binops:");
   pp_newline (pp);
   unsigned i;
-  const binop_svalue2 *binop;
+  const binop_svalue *binop;
   FOR_EACH_VEC_ELT (m_iterated_binops, i, binop)
     {
       pp_string (pp, "  ");
@@ -8567,7 +7148,7 @@ model2_merger::dump_to_pp (pretty_printer *pp, bool simple) const
 /* Dump a multiline representation of this merger to FILE.  */
 
 void
-model2_merger::dump (FILE *fp, bool simple) const
+model_merger::dump (FILE *fp, bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -8580,7 +7161,7 @@ model2_merger::dump (FILE *fp, bool simple) const
 /* Dump a multiline representation of this merger to stderr.  */
 
 DEBUG_FUNCTION void
-model2_merger::dump (bool simple) const
+model_merger::dump (bool simple) const
 {
   dump (stderr, simple);
 }
@@ -8588,36 +7169,36 @@ model2_merger::dump (bool simple) const
 /* FIXME.  */
 #if ITERATED_BINOPS
 void
-model2_merger::add_iterating_widening_binop_thing (const binop_svalue2 *binop_sval)
+model_merger::add_iterating_widening_binop_thing (const binop_svalue *binop_sval)
 {
   // TODO!
   m_iterated_binops.safe_push (binop_sval);
 }
 #endif
 
-/* struct svalue2_id_merger_mapping.  */
+/* struct svalue_id_merger_mapping.  */
 
 #if 0
-/* svalue2_id_merger_mapping's ctor.  */
+/* svalue_id_merger_mapping's ctor.  */
 
-svalue2_id_merger_mapping::svalue2_id_merger_mapping (const region_model2 &a,
-						    const region_model2 &b)
-: m_map_from_a_to_m (a.get_num_svalue2s ()),
-  m_map_from_b_to_m (b.get_num_svalue2s ())
+svalue_id_merger_mapping::svalue_id_merger_mapping (const region_model &a,
+						    const region_model &b)
+: m_map_from_a_to_m (a.get_num_svalues ()),
+  m_map_from_b_to_m (b.get_num_svalues ())
 {
 }
 
 /* Dump a multiline representation of this to PP.  */
 
 void
-svalue2_id_merger_mapping::dump_to_pp (pretty_printer *pp) const
+svalue_id_merger_mapping::dump_to_pp (pretty_printer *pp) const
 {
-  pp_string (pp, "svalue2 *map: model A to merged model:");
+  pp_string (pp, "svalue *map: model A to merged model:");
   pp_newline (pp);
   m_map_from_a_to_m.dump_to_pp (pp);
   pp_newline (pp);
 
-  pp_string (pp, "svalue2 *map: model B to merged model:");
+  pp_string (pp, "svalue *map: model B to merged model:");
   pp_newline (pp);
   m_map_from_b_to_m.dump_to_pp (pp);
   pp_newline (pp);
@@ -8626,7 +7207,7 @@ svalue2_id_merger_mapping::dump_to_pp (pretty_printer *pp) const
 /* Dump a multiline representation of this to FILE.  */
 
 void
-svalue2_id_merger_mapping::dump (FILE *fp) const
+svalue_id_merger_mapping::dump (FILE *fp) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -8639,7 +7220,7 @@ svalue2_id_merger_mapping::dump (FILE *fp) const
 /* Dump a multiline representation of this to stderr.  */
 
 DEBUG_FUNCTION void
-svalue2_id_merger_mapping::dump () const
+svalue_id_merger_mapping::dump () const
 {
   dump (stderr);
 }
@@ -8650,17 +7231,17 @@ svalue2_id_merger_mapping::dump () const
 /* Dump RMODEL fully to stderr (i.e. without summarization).  */
 
 DEBUG_FUNCTION void
-debug (const region_model2 &rmodel)
+debug (const region_model &rmodel)
 {
   rmodel.dump (false);
 }
 
-/* class engine2.  */
+/* class engine.  */
 
 /* FIXME.  */
 
 void
-engine2::log_stats (logger *logger) const
+engine::log_stats (logger *logger) const
 {
   m_mgr.log_stats (logger, true);
 }
@@ -8723,23 +7304,23 @@ test_tree_cmp_on_constants ()
 	}
 }
 
-/* Implementation detail of the ASSERT_CONDITION_*2 macros.  */
+/* Implementation detail of the ASSERT_CONDITION_* macros.  */
 
 void
-assert_condition2 (const location &loc,
-		   region_model2 &model,
-		   const svalue2 *lhs, tree_code op, const svalue2 *rhs,
+assert_condition (const location &loc,
+		   region_model &model,
+		   const svalue *lhs, tree_code op, const svalue *rhs,
 		   tristate expected)
 {
   tristate actual = model.eval_condition (lhs, op, rhs);
   ASSERT_EQ_AT (loc, actual, expected);
 }
 
-/* Implementation detail of the ASSERT_CONDITION_*2 macros.  */
+/* Implementation detail of the ASSERT_CONDITION_* macros.  */
 
 void
-assert_condition2 (const location &loc,
-		   region_model2 &model,
+assert_condition (const location &loc,
+		   region_model &model,
 		   tree lhs, tree_code op, tree rhs,
 		   tristate expected)
 {
@@ -8770,7 +7351,7 @@ assert_dump_tree_eq (const location &loc, tree t, const char *expected)
 
 static void
 assert_dump_eq (const location &loc,
-		const region_model2 &model,
+		const region_model &model,
 		bool summarize,
 		const char *expected)
 {
@@ -8789,24 +7370,24 @@ assert_dump_eq (const location &loc,
   assert_dump_eq ((SELFTEST_LOCATION), (MODEL), (SUMMARIZE), (EXPECTED)); \
   SELFTEST_END_STMT
 
-/* Smoketest for region_model2::dump_to_pp.  */
+/* Smoketest for region_model::dump_to_pp.  */
 
 static void
 test_dump ()
 {
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
 
   ASSERT_DUMP_EQ (model, false,
 		  "stack depth: 0\n"
 		  "m_called_unknown_fn: FALSE\n"
-		  "constraint_manager2:\n"
+		  "constraint_manager:\n"
 		  "  equiv classes:\n"
 		  "  constraints:\n");
   ASSERT_DUMP_EQ (model, true,
 		  "stack depth: 0\n"
 		  "m_called_unknown_fn: FALSE\n"
-		  "constraint_manager2:\n"
+		  "constraint_manager:\n"
 		  "  equiv classes:\n"
 		  "  constraints:\n");
 }
@@ -8857,9 +7438,9 @@ make_test_compound_type (const char *name, bool is_struct,
 
 /* Selftest fixture for creating the type "struct coord {int x; int y; };".  */
 
-struct coord_test2
+struct coord_test
 {
-  coord_test2 ()
+  coord_test ()
   {
     auto_vec<tree> fields;
     m_x_field = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
@@ -8881,7 +7462,7 @@ struct coord_test2
 static void
 test_dump_2 ()
 {
-  coord_test2 ct;
+  coord_test ct;
 
   tree c = build_global_decl ("c", ct.m_coord_type);
   tree c_x = build3 (COMPONENT_REF, TREE_TYPE (ct.m_x_field),
@@ -8892,8 +7473,8 @@ test_dump_2 ()
   tree int_17 = build_int_cst (integer_type_node, 17);
   tree int_m3 = build_int_cst (integer_type_node, -3);
 
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
   model.set_value (c_x, int_17, NULL);
   model.set_value (c_y, int_m3, NULL);
 
@@ -8901,7 +7482,7 @@ test_dump_2 ()
 
   /* Verify get_offset for "c.x".  */
   {
-    const region2 *c_x_reg = model.get_lvalue (c_x, NULL);
+    const region *c_x_reg = model.get_lvalue (c_x, NULL);
     region_offset offset = c_x_reg->get_offset ();
     ASSERT_EQ (offset.get_base_region (), model.get_lvalue (c, NULL));
     ASSERT_EQ (offset.get_bit_offset (), 0);
@@ -8909,7 +7490,7 @@ test_dump_2 ()
 
   /* Verify get_offset for "c.y".  */
   {
-    const region2 *c_y_reg = model.get_lvalue (c_y, NULL);
+    const region *c_y_reg = model.get_lvalue (c_y, NULL);
     region_offset offset = c_y_reg->get_offset ();
     ASSERT_EQ (offset.get_base_region (), model.get_lvalue (c, NULL));
     ASSERT_EQ (offset.get_bit_offset (), INT_TYPE_SIZE);
@@ -8934,7 +7515,7 @@ test_dump_2 ()
 #if 0
   ASSERT_DUMP_EQ
     (model, false,
-     "base region: {decl_region2(globals, `struct coord', `c')} has cluster: {binding key: {region: field_region2(decl_region2(globals, `struct coord', `c'), `int', `x'), kind: direct, offset: 0}, value: {constant_svalue2(`int', 17)}, binding key: {region: field_region2(decl_region2(globals, `struct coord', `c'), `int', `y'), kind: direct, offset: 0}, value: {constant_svalue2(`int', -3)}}");
+     "base region: {decl_region(globals, `struct coord', `c')} has cluster: {binding key: {region: field_region(decl_region(globals, `struct coord', `c'), `int', `x'), kind: direct, offset: 0}, value: {constant_svalue(`int', 17)}, binding key: {region: field_region(decl_region(globals, `struct coord', `c'), `int', `y'), kind: direct, offset: 0}, value: {constant_svalue(`int', -3)}}");
 #endif
 }
 
@@ -8950,7 +7531,7 @@ test_dump_3 ()
 
   tree a = build_global_decl ("a", arr_type);
 
-  region_model2 model;
+  region_model model;
   tree int_0 = build_int_cst (integer_type_node, 0);
   tree a_0 = build4 (ARRAY_REF, char_type_node,
 		     a, int_0, NULL_TREE, NULL_TREE);
@@ -8961,36 +7542,22 @@ test_dump_3 ()
   ASSERT_DUMP_EQ (model, true, "a[0]: 65");
 
   /* Full dump.  */
-  ASSERT_DUMP_EQ
-    (model, false,
-     "r0: {kind: `root', parent: null, sval: null}\n"
-     "`-globals: r1: {kind: `globals', parent: r0, sval: null, map: {`a': r2}}\n"
-     "  `-`a': r2: {kind: `array', parent: r1, sval: null, type: `char[11]', array: {[0]: r3}}\n"
-     "    |: type: `char[11]'\n"
-     "    `-[0]: r3: {kind: `primitive', parent: r2, sval: sv1, type: `char'}\n"
-     "      |: sval: sv1: {type: `char', `65'}\n"
-     "      |: type: `char'\n"
-     "svalue2s:\n"
-     "  sv0: {type: `int', `0'}\n"
-     "  sv1: {type: `char', `65'}\n"
-     "constraint manager:\n"
-     "  equiv classes:\n"
-     "  constraints:\n");
+  // TODO
 }
 
 #endif
-/* Verify that region_model2::get_representative_tree works as expected.  */
+/* Verify that region_model::get_representative_tree works as expected.  */
 
 static void
 test_get_representative_tree ()
 {
-  region_model2_manager mgr;
+  region_model_manager mgr;
 
   /* STRING_CST.  */
   {
     tree string_cst = build_string (4, "foo");
-    region_model2 m (&mgr);
-    const svalue2 *str_sval = m.get_rvalue (string_cst, NULL);
+    region_model m (&mgr);
+    const svalue *str_sval = m.get_rvalue (string_cst, NULL);
     tree rep = m.get_representative_tree (str_sval);
     ASSERT_EQ (rep, string_cst);
   }
@@ -8998,8 +7565,8 @@ test_get_representative_tree ()
   /* String literal.  */
   {
     tree string_cst_ptr = build_string_literal (4, "foo");
-    region_model2 m (&mgr);
-    const svalue2 *str_sval = m.get_rvalue (string_cst_ptr, NULL);
+    region_model m (&mgr);
+    const svalue *str_sval = m.get_rvalue (string_cst_ptr, NULL);
     tree rep = m.get_representative_tree (str_sval);
     ASSERT_DUMP_TREE_EQ (rep, "&\"foo\"[0]");
   }
@@ -9014,16 +7581,16 @@ test_get_representative_tree ()
     tree tlen = size_int (10);
     tree arr_type = build_array_type (char_type_node, build_index_type (tlen));
     tree a = build_global_decl ("a", arr_type);
-    placeholder_svalue2 test_sval (char_type_node, "test value");
+    placeholder_svalue test_sval (char_type_node, "test value");
 
     /* Value of a[3].  */
     {
-      test_region_model2_context ctxt;
-      region_model2 model (&mgr);
+      test_region_model_context ctxt;
+      region_model model (&mgr);
       tree int_3 = build_int_cst (integer_type_node, 3);
       tree a_3 = build4 (ARRAY_REF, char_type_node,
 			 a, int_3, NULL_TREE, NULL_TREE);
-      const region2 *a_3_reg = model.get_lvalue (a_3, &ctxt);
+      const region *a_3_reg = model.get_lvalue (a_3, &ctxt);
       model.set_value (a_3_reg, &test_sval, &ctxt);
       tree rep = model.get_representative_tree (&test_sval);
       ASSERT_DUMP_TREE_EQ (rep, "a[3]");
@@ -9031,12 +7598,12 @@ test_get_representative_tree ()
 
     /* Value of a[0].  */
     {
-      test_region_model2_context ctxt;
-      region_model2 model (&mgr);
+      test_region_model_context ctxt;
+      region_model model (&mgr);
       tree idx = build_int_cst (integer_type_node, 0);
       tree a_0 = build4 (ARRAY_REF, char_type_node,
 			 a, idx, NULL_TREE, NULL_TREE);
-      const region2 *a_0_reg = model.get_lvalue (a_0, &ctxt);
+      const region *a_0_reg = model.get_lvalue (a_0, &ctxt);
       model.set_value (a_0_reg, &test_sval, &ctxt);
       tree rep = model.get_representative_tree (&test_sval);
       ASSERT_DUMP_TREE_EQ (rep, "a[0]");
@@ -9045,7 +7612,7 @@ test_get_representative_tree ()
 
   /* Value of a field within a struct.  */
   {
-    coord_test2 ct;
+    coord_test ct;
 
     tree c = build_global_decl ("c", ct.m_coord_type);
     tree c_x = build3 (COMPONENT_REF, TREE_TYPE (ct.m_x_field),
@@ -9053,13 +7620,13 @@ test_get_representative_tree ()
     tree c_y = build3 (COMPONENT_REF, TREE_TYPE (ct.m_y_field),
 		       c, ct.m_y_field, NULL_TREE);
 
-    test_region_model2_context ctxt;
+    test_region_model_context ctxt;
 
     /* Value of initial field.  */
     {
-      region_model2 m (&mgr);
-      const region2 *c_x_reg = m.get_lvalue (c_x, &ctxt);
-      placeholder_svalue2 test_sval_x (integer_type_node, "test x val");
+      region_model m (&mgr);
+      const region *c_x_reg = m.get_lvalue (c_x, &ctxt);
+      placeholder_svalue test_sval_x (integer_type_node, "test x val");
       m.set_value (c_x_reg, &test_sval_x, &ctxt);
       tree rep = m.get_representative_tree (&test_sval_x);
       ASSERT_DUMP_TREE_EQ (rep, "c.x");
@@ -9067,9 +7634,9 @@ test_get_representative_tree ()
 
     /* Value of non-initial field.  */
     {
-      region_model2 m (&mgr);
-      const region2 *c_y_reg = m.get_lvalue (c_y, &ctxt);
-      placeholder_svalue2 test_sval_y (integer_type_node, "test y val");
+      region_model m (&mgr);
+      const region *c_y_reg = m.get_lvalue (c_y, &ctxt);
+      placeholder_svalue test_sval_y (integer_type_node, "test y val");
       m.set_value (c_y_reg, &test_sval_y, &ctxt);
       tree rep = m.get_representative_tree (&test_sval_y);
       ASSERT_DUMP_TREE_EQ (rep, "c.y");
@@ -9082,8 +7649,8 @@ test_get_representative_tree ()
   }
 }
 
-/* Verify that calling region_model2::get_rvalue repeatedly on the same
-   tree constant retrieves the same svalue2 *.  */
+/* Verify that calling region_model::get_rvalue repeatedly on the same
+   tree constant retrieves the same svalue *.  */
 
 static void
 test_unique_constants ()
@@ -9091,9 +7658,9 @@ test_unique_constants ()
   tree int_0 = build_int_cst (integer_type_node, 0);
   tree int_42 = build_int_cst (integer_type_node, 42);
 
-  test_region_model2_context ctxt;
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  test_region_model_context ctxt;
+  region_model_manager mgr;
+  region_model model (&mgr);
   ASSERT_EQ (model.get_rvalue (int_0, &ctxt), model.get_rvalue (int_0, &ctxt));
   ASSERT_EQ (model.get_rvalue (int_42, &ctxt),
 	     model.get_rvalue (int_42, &ctxt));
@@ -9105,58 +7672,58 @@ test_unique_constants ()
     = build_qualified_type (integer_type_node, TYPE_QUAL_CONST);
   tree const_int_42 = build_int_cst (const_int_type_node, 42);
   ASSERT_NE (int_42, const_int_42);
-  /* It should have a different const_svalue2.  */
-  const svalue2 *int_42_sval = model.get_rvalue (int_42, &ctxt);
-  const svalue2 *const_int_42_sval = model.get_rvalue (const_int_42, &ctxt);
+  /* It should have a different const_svalue.  */
+  const svalue *int_42_sval = model.get_rvalue (int_42, &ctxt);
+  const svalue *const_int_42_sval = model.get_rvalue (const_int_42, &ctxt);
   ASSERT_NE (int_42_sval, const_int_42_sval);
   /* But they should compare as equal.  */
-  ASSERT_CONDITION_TRUE2 (model, int_42_sval, EQ_EXPR, const_int_42_sval);
-  ASSERT_CONDITION_FALSE2 (model, int_42_sval, NE_EXPR, const_int_42_sval);
+  ASSERT_CONDITION_TRUE (model, int_42_sval, EQ_EXPR, const_int_42_sval);
+  ASSERT_CONDITION_FALSE (model, int_42_sval, NE_EXPR, const_int_42_sval);
 }
 
-/* Verify that each type gets its own singleton unknown_svalue2 within a
-   region_model2_manager, and that NULL_TREE gets its own singleton.  */
+/* Verify that each type gets its own singleton unknown_svalue within a
+   region_model_manager, and that NULL_TREE gets its own singleton.  */
 
 static void
 test_unique_unknowns ()
 {
-  region_model2_manager mgr;
-  const svalue2 *unknown_int
-    = mgr.get_or_create_unknown_svalue2 (integer_type_node);
+  region_model_manager mgr;
+  const svalue *unknown_int
+    = mgr.get_or_create_unknown_svalue (integer_type_node);
   /* Repeated calls with the same type should get the same "unknown"
-     svalue2.  */
-  const svalue2 *unknown_int_2
-    = mgr.get_or_create_unknown_svalue2 (integer_type_node);
+     svalue.  */
+  const svalue *unknown_int_2
+    = mgr.get_or_create_unknown_svalue (integer_type_node);
   ASSERT_EQ (unknown_int, unknown_int_2);
 
   /* Different types (or the NULL type) should have different
-     unknown_svalue2s.  */
-  const svalue2 *unknown_NULL_type = mgr.get_or_create_unknown_svalue2 (NULL);
+     unknown_svalues.  */
+  const svalue *unknown_NULL_type = mgr.get_or_create_unknown_svalue (NULL);
   ASSERT_NE (unknown_NULL_type, unknown_int);
 
   /* Repeated calls with NULL for the type should get the same "unknown"
-     svalue2.  */
-  const svalue2 *unknown_NULL_type_2 = mgr.get_or_create_unknown_svalue2 (NULL);
+     svalue.  */
+  const svalue *unknown_NULL_type_2 = mgr.get_or_create_unknown_svalue (NULL);
   ASSERT_EQ (unknown_NULL_type, unknown_NULL_type_2);
 }
 
 #if 0
 /* Check that operator== and hashing works as expected for the
-   various svalue2 subclasses.  */
+   various svalue subclasses.  */
 
 static void
-test_svalue2_equality ()
+test_svalue_equality ()
 {
   tree int_42 = build_int_cst (integer_type_node, 42);
   tree int_0 = build_int_cst (integer_type_node, 0);
 
-  /* Create pairs instances of the various subclasses of svalue2,
+  /* Create pairs instances of the various subclasses of svalue,
      testing for hash and equality between (this, this) and
      (this, other of same subclass). */
-  const svalue2 *ptr_to_r0
-    = new region_svalue2 (ptr_type_node, region2_id::from_int (0));
-  const svalue2 *ptr_to_r1
-    = new region_svalue2 (ptr_type_node, region2_id::from_int (1));
+  const svalue *ptr_to_r0
+    = new region_svalue (ptr_type_node, region_id::from_int (0));
+  const svalue *ptr_to_r1
+    = new region_svalue (ptr_type_node, region_id::from_int (1));
 
   ASSERT_EQ (ptr_to_r0->hash (), ptr_to_r0->hash ());
   ASSERT_EQ (*ptr_to_r0, *ptr_to_r0);
@@ -9164,8 +7731,8 @@ test_svalue2_equality ()
   ASSERT_NE (ptr_to_r0->hash (), ptr_to_r1->hash ());
   ASSERT_NE (*ptr_to_r0, *ptr_to_r1);
 
-  const svalue2 *cst_int_42 = new constant_svalue2 (int_42);
-  const svalue2 *cst_int_0 = new constant_svalue2 (int_0);
+  const svalue *cst_int_42 = new constant_svalue (int_42);
+  const svalue *cst_int_0 = new constant_svalue (int_0);
 
   ASSERT_EQ (cst_int_42->hash (), cst_int_42->hash ());
   ASSERT_EQ (*cst_int_42, *cst_int_42);
@@ -9173,8 +7740,8 @@ test_svalue2_equality ()
   ASSERT_NE (cst_int_42->hash (), cst_int_0->hash ());
   ASSERT_NE (*cst_int_42, *cst_int_0);
 
-  const svalue2 *uninit = new poisoned_svalue2 (POISON_KIND_UNINIT, NULL_TREE);
-  const svalue2 *freed = new poisoned_svalue2 (POISON_KIND_FREED, NULL_TREE);
+  const svalue *uninit = new poisoned_svalue (POISON_KIND_UNINIT, NULL_TREE);
+  const svalue *freed = new poisoned_svalue (POISON_KIND_FREED, NULL_TREE);
 
   ASSERT_EQ (uninit->hash (), uninit->hash ());
   ASSERT_EQ (*uninit, *uninit);
@@ -9182,13 +7749,13 @@ test_svalue2_equality ()
   ASSERT_NE (uninit->hash (), freed->hash ());
   ASSERT_NE (*uninit, *freed);
 
-  const svalue2 *unknown_0 = new unknown_svalue2 (ptr_type_node);
-  const svalue2 *unknown_1 = new unknown_svalue2 (ptr_type_node);
+  const svalue *unknown_0 = new unknown_svalue (ptr_type_node);
+  const svalue *unknown_1 = new unknown_svalue (ptr_type_node);
   ASSERT_EQ (unknown_0->hash (), unknown_0->hash ());
   ASSERT_EQ (*unknown_0, *unknown_0);
   ASSERT_EQ (*unknown_1, *unknown_1);
 
-  /* Comparisons between different kinds of svalue2.  */
+  /* Comparisons between different kinds of svalue.  */
   ASSERT_NE (*ptr_to_r0, *cst_int_42);
   ASSERT_NE (*ptr_to_r0, *uninit);
   ASSERT_NE (*ptr_to_r0, *unknown_0);
@@ -9213,15 +7780,15 @@ test_svalue2_equality ()
 }
 
 /* Check that operator== and hashing works as expected for the
-   various region2 subclasses.  */
+   various region subclasses.  */
 
 static void
-test_region2_equality ()
+test_region_equality ()
 {
-  region2 *r0
-    = new primitive_region2 (region2_id::from_int (3), integer_type_node);
-  region2 *r1
-    = new primitive_region2 (region2_id::from_int (4), integer_type_node);
+  region *r0
+    = new primitive_region (region_id::from_int (3), integer_type_node);
+  region *r1
+    = new primitive_region (region_id::from_int (4), integer_type_node);
 
   ASSERT_EQ (*r0, *r0);
   ASSERT_EQ (r0->hash (), r0->hash ());
@@ -9231,25 +7798,25 @@ test_region2_equality ()
   delete r0;
   delete r1;
 
-  // TODO: test coverage for the map within a map_region2
+  // TODO: test coverage for the map within a map_region
 }
 #endif
 
-/* Verify that initial_svalue2 are handled as expected.  */
+/* Verify that initial_svalue are handled as expected.  */
 
 static void
-test_initial_svalue2_folding ()
+test_initial_svalue_folding ()
 {
-  region_model2_manager mgr;
+  region_model_manager mgr;
   tree x = build_global_decl ("x", integer_type_node);
   tree y = build_global_decl ("y", integer_type_node);
 
-  test_region_model2_context ctxt;
-  region_model2 model (&mgr);
-  const svalue2 *x_init = model.get_rvalue (x, &ctxt);
-  const svalue2 *y_init = model.get_rvalue (y, &ctxt);
+  test_region_model_context ctxt;
+  region_model model (&mgr);
+  const svalue *x_init = model.get_rvalue (x, &ctxt);
+  const svalue *y_init = model.get_rvalue (y, &ctxt);
   ASSERT_NE (x_init, y_init);
-  const region2 *x_reg = model.get_lvalue (x, &ctxt);
+  const region *x_reg = model.get_lvalue (x, &ctxt);
   ASSERT_EQ (x_init, mgr.get_or_create_initial_value (x_reg));
 
 }
@@ -9257,17 +7824,17 @@ test_initial_svalue2_folding ()
 /* Verify that unary ops are folded as expected.  */
 
 static void
-test_unaryop_svalue2_folding ()
+test_unaryop_svalue_folding ()
 {
-  region_model2_manager mgr;
+  region_model_manager mgr;
   tree x = build_global_decl ("x", integer_type_node);
   tree y = build_global_decl ("y", integer_type_node);
 
-  test_region_model2_context ctxt;
-  region_model2 model (&mgr);
-  const svalue2 *x_init = model.get_rvalue (x, &ctxt);
-  const svalue2 *y_init = model.get_rvalue (y, &ctxt);
-  const region2 *x_reg = model.get_lvalue (x, &ctxt);
+  test_region_model_context ctxt;
+  region_model model (&mgr);
+  const svalue *x_init = model.get_rvalue (x, &ctxt);
+  const svalue *y_init = model.get_rvalue (y, &ctxt);
+  const region *x_reg = model.get_lvalue (x, &ctxt);
   ASSERT_EQ (x_init, mgr.get_or_create_initial_value (x_reg));
 
   /* "(int)x" -> "x".  */
@@ -9295,17 +7862,17 @@ test_unaryop_svalue2_folding ()
 /* Verify that binops on constant svalues are folded.  */
 
 static void
-test_binop_svalue2_folding ()
+test_binop_svalue_folding ()
 {
 #define NUM_CSTS 10
   tree cst_int[NUM_CSTS];
-  region_model2_manager mgr;
-  const svalue2 *cst_sval[NUM_CSTS];
+  region_model_manager mgr;
+  const svalue *cst_sval[NUM_CSTS];
   for (int i = 0; i < NUM_CSTS; i++)
     {
       cst_int[i] = build_int_cst (integer_type_node, i);
-      cst_sval[i] = mgr.get_or_create_constant_svalue2 (cst_int[i]);
-      ASSERT_EQ (cst_sval[i]->get_kind (), svalue2::SK_CONSTANT);
+      cst_sval[i] = mgr.get_or_create_constant_svalue (cst_int[i]);
+      ASSERT_EQ (cst_sval[i]->get_kind (), svalue::SK_CONSTANT);
       ASSERT_EQ (cst_sval[i]->maybe_get_constant (), cst_int[i]);
     }
 
@@ -9316,29 +7883,29 @@ test_binop_svalue2_folding ()
 	  ASSERT_NE (cst_sval[i], cst_sval[j]);
 	if (i + j < NUM_CSTS)
 	  {
-	    const svalue2 *sum
+	    const svalue *sum
 	      = mgr.get_or_create_binop (integer_type_node, PLUS_EXPR,
 					 cst_sval[i], cst_sval[j]);
 	    ASSERT_EQ (sum, cst_sval[i + j]);
 	  }
 	if (i - j >= 0)
 	  {
-	    const svalue2 *difference
+	    const svalue *difference
 	      = mgr.get_or_create_binop (integer_type_node, MINUS_EXPR,
 					 cst_sval[i], cst_sval[j]);
 	    ASSERT_EQ (difference, cst_sval[i - j]);
 	  }
 	if (i * j < NUM_CSTS)
 	  {
-	    const svalue2 *product
+	    const svalue *product
 	      = mgr.get_or_create_binop (integer_type_node, MULT_EXPR,
 					 cst_sval[i], cst_sval[j]);
 	    ASSERT_EQ (product, cst_sval[i * j]);
 	  }
-	const svalue2 *eq = mgr.get_or_create_binop (integer_type_node, EQ_EXPR,
+	const svalue *eq = mgr.get_or_create_binop (integer_type_node, EQ_EXPR,
 					       cst_sval[i], cst_sval[j]);
 	ASSERT_EQ (eq, i == j ? cst_sval[1] : cst_sval [0]);
-	const svalue2 *neq = mgr.get_or_create_binop (integer_type_node, NE_EXPR,
+	const svalue *neq = mgr.get_or_create_binop (integer_type_node, NE_EXPR,
 						cst_sval[i], cst_sval[j]);
 	ASSERT_EQ (neq, i != j ? cst_sval[1] : cst_sval [0]);
 	// etc
@@ -9346,35 +7913,35 @@ test_binop_svalue2_folding ()
 
   tree x = build_global_decl ("x", integer_type_node);
 
-  test_region_model2_context ctxt;
-  region_model2 model (&mgr);
-  const svalue2 *x_init = model.get_rvalue (x, &ctxt);
+  test_region_model_context ctxt;
+  region_model model (&mgr);
+  const svalue *x_init = model.get_rvalue (x, &ctxt);
 
   /* PLUS_EXPR folding.  */
-  const svalue2 *x_init_plus_zero
+  const svalue *x_init_plus_zero
     = mgr.get_or_create_binop (integer_type_node, PLUS_EXPR,
 			       x_init, cst_sval[0]);
   ASSERT_EQ (x_init_plus_zero, x_init);
-  const svalue2 *zero_plus_x_init
+  const svalue *zero_plus_x_init
     = mgr.get_or_create_binop (integer_type_node, PLUS_EXPR,
 			       cst_sval[0], x_init);
   ASSERT_EQ (zero_plus_x_init, x_init);
 
   /* MULT_EXPR folding.  */
-  const svalue2 *x_init_times_zero
+  const svalue *x_init_times_zero
     = mgr.get_or_create_binop (integer_type_node, MULT_EXPR,
 			       x_init, cst_sval[0]);
   ASSERT_EQ (x_init_times_zero, cst_sval[0]);
-  const svalue2 *zero_times_x_init
+  const svalue *zero_times_x_init
     = mgr.get_or_create_binop (integer_type_node, MULT_EXPR,
 			       cst_sval[0], x_init);
   ASSERT_EQ (zero_times_x_init, cst_sval[0]);
 
-  const svalue2 *x_init_times_one
+  const svalue *x_init_times_one
     = mgr.get_or_create_binop (integer_type_node, MULT_EXPR,
 			       x_init, cst_sval[1]);
   ASSERT_EQ (x_init_times_one, x_init);
-  const svalue2 *one_times_x_init
+  const svalue *one_times_x_init
     = mgr.get_or_create_binop (integer_type_node, MULT_EXPR,
 			       cst_sval[1], x_init);
   ASSERT_EQ (one_times_x_init, x_init);
@@ -9383,66 +7950,66 @@ test_binop_svalue2_folding ()
   // TODO: do we want to use the match-and-simplify DSL for this?
 
   /* Verify that binops put any constants on the RHS.  */
-  const svalue2 *four_times_x_init
+  const svalue *four_times_x_init
     = mgr.get_or_create_binop (integer_type_node, MULT_EXPR,
 			       cst_sval[4], x_init);
-  const svalue2 *x_init_times_four
+  const svalue *x_init_times_four
     = mgr.get_or_create_binop (integer_type_node, MULT_EXPR,
 			       x_init, cst_sval[4]);
   ASSERT_EQ (four_times_x_init, x_init_times_four);
-  const binop_svalue2 *binop = four_times_x_init->dyn_cast_binop_svalue2 ();
+  const binop_svalue *binop = four_times_x_init->dyn_cast_binop_svalue ();
   ASSERT_EQ (binop->get_op (), MULT_EXPR);
   ASSERT_EQ (binop->get_arg0 (), x_init);
   ASSERT_EQ (binop->get_arg1 (), cst_sval[4]);
 
   /* Verify that ((x + 1) + 1) == (x + 2).  */
-  const svalue2 *x_init_plus_one
+  const svalue *x_init_plus_one
     = mgr.get_or_create_binop (integer_type_node, PLUS_EXPR,
 			       x_init, cst_sval[1]);
-  const svalue2 *x_init_plus_two
+  const svalue *x_init_plus_two
     = mgr.get_or_create_binop (integer_type_node, PLUS_EXPR,
 			       x_init, cst_sval[2]);
-  const svalue2 *x_init_plus_one_plus_one
+  const svalue *x_init_plus_one_plus_one
     = mgr.get_or_create_binop (integer_type_node, PLUS_EXPR,
 			       x_init_plus_one, cst_sval[1]);
   ASSERT_EQ (x_init_plus_one_plus_one, x_init_plus_two);
 }
 
-/* Verify that sub_svalue2s are folded as expected.  */
+/* Verify that sub_svalues are folded as expected.  */
 
 static void
-test_sub_svalue2_folding ()
+test_sub_svalue_folding ()
 {
-  coord_test2 ct;
+  coord_test ct;
   tree c = build_global_decl ("c", ct.m_coord_type);
   tree c_x = build3 (COMPONENT_REF, TREE_TYPE (ct.m_x_field),
 		     c, ct.m_x_field, NULL_TREE);
 
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
-  test_region_model2_context ctxt;
-  const region2 *c_x_reg = model.get_lvalue (c_x, &ctxt);
+  region_model_manager mgr;
+  region_model model (&mgr);
+  test_region_model_context ctxt;
+  const region *c_x_reg = model.get_lvalue (c_x, &ctxt);
 
-  /* Verify that sub_svalue2 of "unknown" simply
+  /* Verify that sub_svalue of "unknown" simply
      yields an unknown.  */
 
-  const svalue2 *unknown = mgr.get_or_create_unknown_svalue2 (ct.m_coord_type);
-  const svalue2 *sub = mgr.get_or_create_sub_svalue2 (TREE_TYPE (ct.m_x_field),
+  const svalue *unknown = mgr.get_or_create_unknown_svalue (ct.m_coord_type);
+  const svalue *sub = mgr.get_or_create_sub_svalue (TREE_TYPE (ct.m_x_field),
 						      unknown, c_x_reg);
-  ASSERT_EQ (sub->get_kind (), svalue2::SK_UNKNOWN);
+  ASSERT_EQ (sub->get_kind (), svalue::SK_UNKNOWN);
   ASSERT_EQ (sub->get_type (), TREE_TYPE (ct.m_x_field));
 }
 
-/* Test that region2::descendent_of_p works as expected.  */
+/* Test that region::descendent_of_p works as expected.  */
 
 static void
 test_descendent_of_p ()
 {
-  region_model2_manager mgr;
-  const region2 *stack = mgr.get_stack_region ();
-  const region2 *heap = mgr.get_heap_region ();
-  const region2 *code = mgr.get_code_region ();
-  const region2 *globals = mgr.get_globals_region ();
+  region_model_manager mgr;
+  const region *stack = mgr.get_stack_region ();
+  const region *heap = mgr.get_heap_region ();
+  const region *code = mgr.get_code_region ();
+  const region *globals = mgr.get_globals_region ();
 
   /* descendent_of_p should return true when used on the region itself.  */
   ASSERT_TRUE (stack->descendent_of_p (stack));
@@ -9451,46 +8018,46 @@ test_descendent_of_p ()
   ASSERT_FALSE (stack->descendent_of_p (globals));
 
   tree x = build_global_decl ("x", integer_type_node);
-  const region2 *x_reg = mgr.get_region_for_global (x);
+  const region *x_reg = mgr.get_region_for_global (x);
   ASSERT_TRUE (x_reg->descendent_of_p (globals));
 
-  /* A cast_region2 should be a descendent of the original region.  */
-  const region2 *cast_reg = mgr.get_cast_region (x_reg, ptr_type_node);
+  /* A cast_region should be a descendent of the original region.  */
+  const region *cast_reg = mgr.get_cast_region (x_reg, ptr_type_node);
   ASSERT_TRUE (cast_reg->descendent_of_p (x_reg));
 }
 
 #if 0
-/* A subclass of purge_criteria for selftests: purge all const svalue2 *instances.  */
+/* A subclass of purge_criteria for selftests: purge all const svalue *instances.  */
 
-class purge_all_svalue2_ids : public purge_criteria
+class purge_all_svalue_ids : public purge_criteria
 {
 public:
-  bool should_purge_p (svalue2_id) const FINAL OVERRIDE
+  bool should_purge_p (svalue_id) const FINAL OVERRIDE
   {
     return true;
   }
 };
 
-/* A subclass of purge_criteria: purge a specific svalue2_id.  */
+/* A subclass of purge_criteria: purge a specific svalue_id.  */
 
-class purge_one_svalue2 *: public purge_criteria
+class purge_one_svalue *: public purge_criteria
 {
 public:
-  purge_one_svalue2 *(svalue2 *victim) : m_victim (victim) {}
+  purge_one_svalue *(svalue *victim) : m_victim (victim) {}
 
-  purge_one_svalue2 *(region_model2 model, tree expr)
+  purge_one_svalue *(region_model model, tree expr)
   : m_victim (model.get_rvalue (expr, NULL)) {}
 
-  bool should_purge_p (svalue2 *sval) const FINAL OVERRIDE
+  bool should_purge_p (svalue *sval) const FINAL OVERRIDE
   {
     return sid == m_victim;
   }
 
 private:
-  svalue2 *m_victim;
+  svalue *m_victim;
 };
 
-/* Check that constraint_manager::purge works for individual svalue2_ids.  */
+/* Check that constraint_manager::purge works for individual svalue_ids.  */
 
 static void
 test_purging_by_criteria ()
@@ -9502,19 +8069,19 @@ test_purging_by_criteria ()
   tree y = build_global_decl ("y", integer_type_node);
 
   {
-    region_model2 model0;
-    region_model2 model1;
+    region_model model0;
+    region_model model1;
 
     ADD_SAT_CONSTRAINT (model1, x, EQ_EXPR, y);
     ASSERT_NE (model0, model1);
 
     purge_stats stats_for_px;
-    purge_one_svalue2 *px (model1, x);
+    purge_one_svalue *px (model1, x);
     model1.get_constraints ()->purge (px, &stats_for_px);
     ASSERT_EQ (stats_for_px.m_num_equiv_classes, 0);
 
     purge_stats stats_for_py;
-    purge_one_svalue2 *py (model1.get_rvalue (y, NULL));
+    purge_one_svalue *py (model1.get_rvalue (y, NULL));
     model1.get_constraints ()->purge (py, &stats_for_py);
     ASSERT_EQ (stats_for_py.m_num_equiv_classes, 1);
 
@@ -9522,22 +8089,22 @@ test_purging_by_criteria ()
   }
 
   {
-    region_model2 model0;
-    region_model2 model1;
+    region_model model0;
+    region_model model1;
 
     ADD_SAT_CONSTRAINT (model1, x, EQ_EXPR, int_42);
     ASSERT_NE (model0, model1);
     ASSERT_CONDITION_TRUE (model1, x, EQ_EXPR, int_42);
 
     purge_stats stats;
-    model1.get_constraints ()->purge (purge_one_svalue2 *(model1, x), &stats);
+    model1.get_constraints ()->purge (purge_one_svalue *(model1, x), &stats);
 
     ASSERT_CONDITION_UNKNOWN (model1, x, EQ_EXPR, int_42);
   }
 
   {
-    region_model2 model0;
-    region_model2 model1;
+    region_model model0;
+    region_model model1;
 
     ADD_SAT_CONSTRAINT (model1, x, GE_EXPR, int_0);
     ADD_SAT_CONSTRAINT (model1, x, LE_EXPR, int_42);
@@ -9547,15 +8114,15 @@ test_purging_by_criteria ()
     ASSERT_CONDITION_TRUE (model1, x, LE_EXPR, int_42);
 
     purge_stats stats;
-    model1.get_constraints ()->purge (purge_one_svalue2 *(model1, x), &stats);
+    model1.get_constraints ()->purge (purge_one_svalue *(model1, x), &stats);
 
     ASSERT_CONDITION_UNKNOWN (model1, x, GE_EXPR, int_0);
     ASSERT_CONDITION_UNKNOWN (model1, x, LE_EXPR, int_42);
   }
 
   {
-    region_model2 model0;
-    region_model2 model1;
+    region_model model0;
+    region_model model1;
 
     ADD_SAT_CONSTRAINT (model1, x, NE_EXPR, int_42);
     ADD_SAT_CONSTRAINT (model1, y, NE_EXPR, int_0);
@@ -9564,7 +8131,7 @@ test_purging_by_criteria ()
     ASSERT_CONDITION_TRUE (model1, y, NE_EXPR, int_0);
 
     purge_stats stats;
-    model1.get_constraints ()->purge (purge_one_svalue2 *(model1, x), &stats);
+    model1.get_constraints ()->purge (purge_one_svalue *(model1, x), &stats);
     ASSERT_NE (model0, model1);
 
     ASSERT_CONDITION_UNKNOWN (model1, x, NE_EXPR, int_42);
@@ -9572,8 +8139,8 @@ test_purging_by_criteria ()
   }
 
   {
-    region_model2 model0;
-    region_model2 model1;
+    region_model model0;
+    region_model model1;
 
     ADD_SAT_CONSTRAINT (model1, x, NE_EXPR, int_42);
     ADD_SAT_CONSTRAINT (model1, y, NE_EXPR, int_0);
@@ -9582,25 +8149,25 @@ test_purging_by_criteria ()
     ASSERT_CONDITION_TRUE (model1, y, NE_EXPR, int_0);
 
     purge_stats stats;
-    model1.get_constraints ()->purge (purge_all_svalue2_ids (), &stats);
+    model1.get_constraints ()->purge (purge_all_svalue_ids (), &stats);
     ASSERT_CONDITION_UNKNOWN (model1, x, NE_EXPR, int_42);
     ASSERT_CONDITION_UNKNOWN (model1, y, NE_EXPR, int_0);
   }
 
 }
 
-/* Test that region_model2::purge_unused_svalue2s works as expected.  */
+/* Test that region_model::purge_unused_svalues works as expected.  */
 
 static void
-test_purge_unused_svalue2s ()
+test_purge_unused_svalues ()
 {
   tree int_42 = build_int_cst (integer_type_node, 42);
   tree int_0 = build_int_cst (integer_type_node, 0);
   tree x = build_global_decl ("x", integer_type_node);
   tree y = build_global_decl ("y", integer_type_node);
 
-  test_region_model2_context ctxt;
-  region_model2 model;
+  test_region_model_context ctxt;
+  region_model model;
   model.set_to_new_unknown_value (model.get_lvalue (x, &ctxt), TREE_TYPE (x),
 				  &ctxt);
   model.set_to_new_unknown_value (model.get_lvalue (x, &ctxt), TREE_TYPE (x),
@@ -9616,8 +8183,8 @@ test_purge_unused_svalue2s ()
 
   /* The redundant unknown values should have been purged.  */
   purge_stats purged;
-  model.purge_unused_svalue2s (&purged, NULL);
-  ASSERT_EQ (purged.m_num_svalue2s, 3);
+  model.purge_unused_svalues (&purged, NULL);
+  ASSERT_EQ (purged.m_num_svalues, 3);
 
   /* and the redundant constraint on an old, unknown value for x should
      have been purged.  */
@@ -9647,15 +8214,15 @@ test_assignment ()
   tree y = build_global_decl ("y", integer_type_node);
 
   /* "x == 0", then use of y, then "y = 0;".  */
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
   ADD_SAT_CONSTRAINT (model, x, EQ_EXPR, int_0);
-  ASSERT_CONDITION_UNKNOWN2 (model, y, EQ_EXPR, int_0);
+  ASSERT_CONDITION_UNKNOWN (model, y, EQ_EXPR, int_0);
   model.set_value (model.get_lvalue (y, NULL),
 		   model.get_rvalue (int_0, NULL),
 		   NULL);
-  ASSERT_CONDITION_TRUE2 (model, y, EQ_EXPR, int_0);
-  ASSERT_CONDITION_TRUE2 (model, y, EQ_EXPR, x);
+  ASSERT_CONDITION_TRUE (model, y, EQ_EXPR, int_0);
+  ASSERT_CONDITION_TRUE (model, y, EQ_EXPR, x);
 
 #if 0
   ASSERT_DUMP_EQ (model, true, "y: 0, {x}: unknown, x == y");
@@ -9667,7 +8234,7 @@ test_assignment ()
 static void
 test_compound_assignment ()
 {
-  coord_test2 ct;
+  coord_test ct;
 
   tree c = build_global_decl ("c", ct.m_coord_type);
   tree c_x = build3 (COMPONENT_REF, TREE_TYPE (ct.m_x_field),
@@ -9683,8 +8250,8 @@ test_compound_assignment ()
   tree int_17 = build_int_cst (integer_type_node, 17);
   tree int_m3 = build_int_cst (integer_type_node, -3);
 
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
   model.set_value (c_x, int_17, NULL);
   model.set_value (c_y, int_m3, NULL);
 
@@ -9695,7 +8262,7 @@ test_compound_assignment ()
   /* Copy c to d.  */
   model.copy_region (model.get_lvalue (d, NULL), model.get_lvalue (c, NULL),
 		     NULL);
-  /* Check that the fields have the same svalue2s.  */
+  /* Check that the fields have the same svalues.  */
   ASSERT_EQ (model.get_rvalue (c_x, NULL), model.get_rvalue (d_x, NULL));
   ASSERT_EQ (model.get_rvalue (c_y, NULL), model.get_rvalue (d_y, NULL));
 }
@@ -9742,17 +8309,17 @@ test_stack_frames ()
   /* "q" global.  */
   tree q = build_global_decl ("q", ptr_type_node);
 
-  region_model2_manager mgr;
-  test_region_model2_context ctxt;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  test_region_model_context ctxt;
+  region_model model (&mgr);
 
   /* Push stack frame for "parent_fn".  */
-  const region2 *parent_frame_reg
+  const region *parent_frame_reg
     = model.push_frame (DECL_STRUCT_FUNCTION (parent_fndecl),
 			NULL, &ctxt);
   ASSERT_EQ (model.get_current_frame (), parent_frame_reg);
   ASSERT_TRUE (model.region_exists_p (parent_frame_reg));
-  const region2 *a_in_parent_reg = model.get_lvalue (a, &ctxt);
+  const region *a_in_parent_reg = model.get_lvalue (a, &ctxt);
   model.set_value (a_in_parent_reg,
 		   model.get_rvalue (int_42, &ctxt),
 		   &ctxt);
@@ -9767,11 +8334,11 @@ test_stack_frames ()
 	     tristate (tristate::TS_TRUE));
 
   /* Push stack frame for "child_fn".  */
-  const region2 *child_frame_reg
+  const region *child_frame_reg
     = model.push_frame (DECL_STRUCT_FUNCTION (child_fndecl), NULL, &ctxt);
   ASSERT_EQ (model.get_current_frame (), child_frame_reg);
   ASSERT_TRUE (model.region_exists_p (child_frame_reg));
-  const region2 *x_in_child_reg = model.get_lvalue (x, &ctxt);
+  const region *x_in_child_reg = model.get_lvalue (x, &ctxt);
   model.set_value (x_in_child_reg,
 		   model.get_rvalue (int_0, &ctxt),
 		   &ctxt);
@@ -9785,25 +8352,25 @@ test_stack_frames ()
 	     tristate (tristate::TS_TRUE));
 
   /* Point a global pointer at a local in the child frame:  p = &x.  */
-  const region2 *p_in_globals_reg = model.get_lvalue (p, &ctxt);
+  const region *p_in_globals_reg = model.get_lvalue (p, &ctxt);
   model.set_value (p_in_globals_reg,
-		   mgr.get_ptr_svalue2 (ptr_type_node, x_in_child_reg),
+		   mgr.get_ptr_svalue (ptr_type_node, x_in_child_reg),
 		   &ctxt);
   ASSERT_EQ (p_in_globals_reg->maybe_get_frame_region (), NULL);
 
   /* Point another global pointer at p: q = &p.  */
-  const region2 *q_in_globals_reg = model.get_lvalue (q, &ctxt);
+  const region *q_in_globals_reg = model.get_lvalue (q, &ctxt);
   model.set_value (q_in_globals_reg,
-		   mgr.get_ptr_svalue2 (ptr_type_node, p_in_globals_reg),
+		   mgr.get_ptr_svalue (ptr_type_node, p_in_globals_reg),
 		   &ctxt);
 
-  /* Test region2::descendent_of_p.  */
+  /* Test region::descendent_of_p.  */
   ASSERT_TRUE (child_frame_reg->descendent_of_p (child_frame_reg));
   ASSERT_TRUE (x_in_child_reg->descendent_of_p (child_frame_reg));
   ASSERT_FALSE (a_in_parent_reg->descendent_of_p (child_frame_reg));
 #if 0
-  auto_vec<region2_id> test_vec;
-  for (region2_id_set::iterator_t iter = descendents.begin ();
+  auto_vec<region_id> test_vec;
+  for (region_id_set::iterator_t iter = descendents.begin ();
        iter != descendents.end ();
        ++iter)
     test_vec.safe_push (*iter);
@@ -9817,17 +8384,17 @@ test_stack_frames ()
 #endif
 
   /* Pop the "child_fn" frame from the stack.  */
-  purge_stats2 purged;
+  purge_stats purged;
   model.pop_frame (NULL, true, &purged, NULL, &ctxt);
   ASSERT_FALSE (model.region_exists_p (child_frame_reg));
   ASSERT_TRUE (model.region_exists_p (parent_frame_reg));
 
 #if 0
   /* We should have purged the unknown values for x and y. */
-  ASSERT_EQ (purged.m_num_svalue2s, 2);
+  ASSERT_EQ (purged.m_num_svalues, 2);
 
-  /* We should have purged the frame region2 and the region2s for x and y. */
-  ASSERT_EQ (purged.m_num_region2s, 3);
+  /* We should have purged the frame region and the regions for x and y. */
+  ASSERT_EQ (purged.m_num_regions, 3);
 
   /* We should have purged the constraint on y.  */
   ASSERT_EQ (purged.m_num_equiv_classes, 1);
@@ -9836,16 +8403,16 @@ test_stack_frames ()
 
   /* Verify that p (which was pointing at the local "x" in the popped
      frame) has been poisoned.  */
-  const svalue2 *new_p_sval = model.get_rvalue (p, &ctxt);
-  ASSERT_EQ (new_p_sval->get_kind (), svalue2::SK_POISONED);
-  ASSERT_EQ (new_p_sval->dyn_cast_poisoned_svalue2 ()->get_poison_kind (),
+  const svalue *new_p_sval = model.get_rvalue (p, &ctxt);
+  ASSERT_EQ (new_p_sval->get_kind (), svalue::SK_POISONED);
+  ASSERT_EQ (new_p_sval->dyn_cast_poisoned_svalue ()->get_poison_kind (),
 	     POISON_KIND_POPPED_STACK);
 
-  /* Verify that q still points to p, in spite of the region2
+  /* Verify that q still points to p, in spite of the region
      renumbering.  */
-  const svalue2 *new_q_sval = model.get_rvalue (q, &ctxt);
-  ASSERT_EQ (new_q_sval->get_kind (), svalue2::SK_REGION);
-  ASSERT_EQ (new_q_sval->dyn_cast_region_svalue2 ()->get_pointee (),
+  const svalue *new_q_sval = model.get_rvalue (q, &ctxt);
+  ASSERT_EQ (new_q_sval->get_kind (), svalue::SK_REGION);
+  ASSERT_EQ (new_q_sval->dyn_cast_region_svalue ()->get_pointee (),
 	     model.get_lvalue (p, &ctxt));
 
   /* Verify that top of stack has been updated.  */
@@ -9853,9 +8420,9 @@ test_stack_frames ()
 
   /* Verify locals in parent frame.  */
   /* Verify "a" still has its value.  */
-  const svalue2 *new_a_sval = model.get_rvalue (a, &ctxt);
-  ASSERT_EQ (new_a_sval->get_kind (), svalue2::SK_CONSTANT);
-  ASSERT_EQ (new_a_sval->dyn_cast_constant_svalue2 ()->get_constant (),
+  const svalue *new_a_sval = model.get_rvalue (a, &ctxt);
+  ASSERT_EQ (new_a_sval->get_kind (), svalue::SK_CONSTANT);
+  ASSERT_EQ (new_a_sval->dyn_cast_constant_svalue ()->get_constant (),
 	     int_42);
   /* Verify "b" still has its constraint.  */
   ASSERT_EQ (model.eval_condition (b, LT_EXPR, int_10, &ctxt),
@@ -9863,7 +8430,7 @@ test_stack_frames ()
 }
 
 /* Verify that get_representative_path_var works as expected, that
-   we can map from region2s to parms and back within a recursive call
+   we can map from regions to parms and back within a recursive call
    stack.  */
 
 static void
@@ -9880,31 +8447,31 @@ test_get_representative_path_var ()
 		       get_identifier ("n"),
 		       integer_type_node);
 
-  region_model2_manager mgr;
-  test_region_model2_context ctxt;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  test_region_model_context ctxt;
+  region_model model (&mgr);
 
   /* Push 5 stack frames for "factorial", each with a param  */
-  auto_vec<const region2 *> parm_regs;
-  auto_vec<const svalue2 *> parm_svals;
+  auto_vec<const region *> parm_regs;
+  auto_vec<const svalue *> parm_svals;
   for (int depth = 0; depth < 5; depth++)
     {
-      const region2 *frame_n_reg
+      const region *frame_n_reg
 	= model.push_frame (DECL_STRUCT_FUNCTION (fndecl), NULL, &ctxt);
-      const region2 *parm_n_reg = model.get_lvalue (path_var (n, depth), &ctxt);
+      const region *parm_n_reg = model.get_lvalue (path_var (n, depth), &ctxt);
       parm_regs.safe_push (parm_n_reg);
 
       ASSERT_EQ (parm_n_reg->get_parent_region (), frame_n_reg);
-      const svalue2 *sval_n = mgr.get_or_create_initial_value (parm_n_reg);
+      const svalue *sval_n = mgr.get_or_create_initial_value (parm_n_reg);
       parm_svals.safe_push (sval_n);
     }
 
-  /* Verify that we can recognize that the region2s are the parms,
+  /* Verify that we can recognize that the regions are the parms,
      at every depth.  */
   for (int depth = 0; depth < 5; depth++)
     {
       {
-	hash_set <const svalue2 *> visited;
+	hash_set <const svalue *> visited;
 	ASSERT_EQ (model.get_representative_path_var (parm_regs[depth],
 						      &visited),
 		   path_var (n, depth + 1));
@@ -9913,9 +8480,9 @@ test_get_representative_path_var ()
 	 not just the top.  */
       ASSERT_EQ (model.get_lvalue (path_var (n, depth), NULL),
 		 parm_regs[depth]);
-      /* ...and that we can locate the svalue2s.  */
+      /* ...and that we can locate the svalues.  */
       {
-	hash_set <const svalue2 *> visited;
+	hash_set <const svalue *> visited;
 	ASSERT_EQ (model.get_representative_path_var (parm_svals[depth],
 						      &visited),
 		   path_var (n, depth + 1));
@@ -9923,7 +8490,7 @@ test_get_representative_path_var ()
     }
 }
 
-/* Verify that "empty" region_model2 instances are equal to each other.  */
+/* Verify that "empty" region_model instances are equal to each other.  */
 
 static void
 test_model_equality_1 ()
@@ -9931,9 +8498,9 @@ test_model_equality_1 ()
   tree int_42 = build_int_cst (integer_type_node, 42);
   tree int_17 = build_int_cst (integer_type_node, 17);
 
-  region_model2_manager mgr;
-  region_model2 model0 (&mgr);
-  region_model2 model1 (&mgr);
+  region_model_manager mgr;
+  region_model model0 (&mgr);
+  region_model model1 (&mgr);
   ASSERT_EQ (model0, model1);
 
   /* Verify that setting state in model1 makes the models non-equal.  */
@@ -9943,7 +8510,7 @@ test_model_equality_1 ()
   ASSERT_NE (model0, model1);
 
   /* Verify the copy-ctor.  */
-  region_model2 model2 (model0);
+  region_model model2 (model0);
   ASSERT_EQ (model0, model2);
   ASSERT_EQ (model2.get_rvalue (x, NULL)->maybe_get_constant (), int_42);
   ASSERT_NE (model1, model2);
@@ -9956,7 +8523,7 @@ test_model_equality_1 ()
   ASSERT_EQ (model0.get_rvalue (x, NULL)->maybe_get_constant (), int_42);
 }
 
-/* Verify that region2 models for
+/* Verify that region models for
       x = 42; y = 113;
    and
       y = 113; x = 42;
@@ -9970,8 +8537,8 @@ test_model_equality_2 ()
   tree x = build_global_decl ("x", integer_type_node);
   tree y = build_global_decl ("y", integer_type_node);
 
-  region_model2_manager mgr;
-  region_model2 model0 (&mgr);
+  region_model_manager mgr;
+  region_model model0 (&mgr);
   model0.set_value (model0.get_lvalue (x, NULL),
 		    model0.get_rvalue (int_42, NULL),
 		    NULL);
@@ -9979,7 +8546,7 @@ test_model_equality_2 ()
 		    model0.get_rvalue (int_113, NULL),
 		    NULL);
 
-  region_model2 model1 (&mgr);
+  region_model model1 (&mgr);
   model1.set_value (model1.get_lvalue (y, NULL),
 		    model1.get_rvalue (int_113, NULL),
 		    NULL);
@@ -10004,12 +8571,12 @@ test_model_equality_3 ()
   tree x = build_global_decl ("x", integer_type_node);
   tree y = build_global_decl ("y", integer_type_node);
 
-  region_model2_manager mgr;
-  region_model2 model0 (&mgr);
+  region_model_manager mgr;
+  region_model model0 (&mgr);
   model0.add_constraint (x, GT_EXPR, int_3, NULL);
   model0.add_constraint (y, GT_EXPR, int_42, NULL);
 
-  region_model2 model1 (&mgr);
+  region_model model1 (&mgr);
   model1.add_constraint (y, GT_EXPR, int_42, NULL);
   model1.add_constraint (x, GT_EXPR, int_3, NULL);
 
@@ -10028,7 +8595,7 @@ test_model_equality_4 ()
   auto_vec<tree> csts;
   append_interesting_constants (&csts);
 
-  region_model2 model;
+  region_model model;
 
   unsigned i;
   tree cst;
@@ -10039,23 +8606,23 @@ test_model_equality_4 ()
 }
 #endif
 
-/* Assert that if we have two region_model2 instances
+/* Assert that if we have two region_model instances
    with values VAL_A and VAL_B for EXPR that they are
    mergable.  Write the merged model to *OUT_MERGED_MODEL,
-   and the merged svalue2 ptr to *OUT_MERGED_SVALUE2.
+   and the merged svalue ptr to *OUT_MERGED_SVALUE.
    If VAL_A or VAL_B are NULL_TREE, don't populate EXPR
-   for that region_model2.  */
+   for that region_model.  */
 
 static void
-assert_region_model2s_merge (tree expr, tree val_a, tree val_b,
-			     region_model2 *out_merged_model,
-			     const svalue2 **out_merged_svalue2)
+assert_region_models_merge (tree expr, tree val_a, tree val_b,
+			     region_model *out_merged_model,
+			     const svalue **out_merged_svalue)
 {
   program_point point (program_point::origin ());
-  test_region_model2_context ctxt;
-  region_model2_manager *mgr = out_merged_model->get_manager ();
-  region_model2 model0 (mgr);
-  region_model2 model1 (mgr);
+  test_region_model_context ctxt;
+  region_model_manager *mgr = out_merged_model->get_manager ();
+  region_model model0 (mgr);
+  region_model model1 (mgr);
   if (val_a)
     model0.set_value (model0.get_lvalue (expr, &ctxt),
 		      model0.get_rvalue (val_a, &ctxt),
@@ -10067,10 +8634,10 @@ assert_region_model2s_merge (tree expr, tree val_a, tree val_b,
 
   /* They should be mergeable.  */
   ASSERT_TRUE (model0.can_merge_with_p (model1, point, out_merged_model));
-  *out_merged_svalue2 = out_merged_model->get_rvalue (expr, &ctxt);
+  *out_merged_svalue = out_merged_model->get_rvalue (expr, &ctxt);
 }
 
-/* Verify that we can merge region_model2 instances.  */
+/* Verify that we can merge region_model instances.  */
 
 static void
 test_state_merging ()
@@ -10101,12 +8668,12 @@ test_state_merging ()
 		       ptr_type_node);
 
   program_point point (program_point::origin ());
-  region_model2_manager mgr;
+  region_model_manager mgr;
 
   {
-    region_model2 model0 (&mgr);
-    region_model2 model1 (&mgr);
-    region_model2 merged (&mgr);
+    region_model model0 (&mgr);
+    region_model model1 (&mgr);
+    region_model merged (&mgr);
     /* Verify empty models can be merged.  */
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
     ASSERT_EQ (model0, merged);
@@ -10117,10 +8684,10 @@ test_state_merging ()
   /* TODO: verify that the merged model doesn't have a value for
      the global  */
   {
-    region_model2 model0 (&mgr);
-    region_model2 model1 (&mgr);
-    region_model2 merged (&mgr);
-    test_region_model2_context ctxt;
+    region_model model0 (&mgr);
+    region_model model1 (&mgr);
+    region_model merged (&mgr);
+    test_region_model_context ctxt;
     model0.add_constraint (x, EQ_EXPR, int_42, &ctxt);
     model1.add_constraint (x, EQ_EXPR, int_113, &ctxt);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
@@ -10130,9 +8697,9 @@ test_state_merging ()
 
   /* Verify handling of a PARM_DECL.  */
   {
-    test_region_model2_context ctxt;
-    region_model2 model0 (&mgr);
-    region_model2 model1 (&mgr);
+    test_region_model_context ctxt;
+    region_model model0 (&mgr);
+    region_model model1 (&mgr);
     ASSERT_EQ (model0.get_stack_depth (), 0);
     model0.push_frame (DECL_STRUCT_FUNCTION (test_fndecl), NULL, &ctxt);
     ASSERT_EQ (model0.get_stack_depth (), 1);
@@ -10142,7 +8709,7 @@ test_state_merging ()
 #endif
     model1.push_frame (DECL_STRUCT_FUNCTION (test_fndecl), NULL, &ctxt);
 
-    placeholder_svalue2 test_sval (integer_type_node, "test sval");
+    placeholder_svalue test_sval (integer_type_node, "test sval");
     model0.set_value (model0.get_lvalue (a, &ctxt), &test_sval, &ctxt);
     model1.set_value (model1.get_lvalue (a, &ctxt), &test_sval, &ctxt);
     ASSERT_EQ (model0, model1);
@@ -10154,7 +8721,7 @@ test_state_merging ()
 #endif
 
     /* They should be mergeable, and the result should be the same.  */
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
     ASSERT_EQ (model0, merged);
     /* In particular, "a" should have the placeholder value.  */
@@ -10164,11 +8731,11 @@ test_state_merging ()
   // FIXME: uses "set_to_new_unknown_value"
   /* Verify handling of a global.  */
   {
-    test_region_model2_context ctxt;
-    region_model2 model0 (&mgr);
-    region_model2 model1 (&mgr);
+    test_region_model_context ctxt;
+    region_model model0 (&mgr);
+    region_model model1 (&mgr);
 
-    placeholder_svalue2 test_sval (integer_type_node, "test sval");
+    placeholder_svalue test_sval (integer_type_node, "test sval");
     model0.set_value (model0.get_lvalue (x, &ctxt), &test_sval, &ctxt);
     model1.set_value (model1.get_lvalue (x, &ctxt), &test_sval, &ctxt);
     ASSERT_EQ (model0, model1);
@@ -10180,7 +8747,7 @@ test_state_merging ()
 #endif
 
     /* They should be mergeable, and the result should be the same.  */
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
     ASSERT_EQ (model0, merged);
     /* In particular, "x" should have the placeholder value.  */
@@ -10191,54 +8758,54 @@ test_state_merging ()
 
   /* Two equal constant values.  */
   {
-    region_model2 merged (&mgr);
-    const svalue2 *merged_x_sval;
-    assert_region_model2s_merge (x, int_42, int_42, &merged, &merged_x_sval);
+    region_model merged (&mgr);
+    const svalue *merged_x_sval;
+    assert_region_models_merge (x, int_42, int_42, &merged, &merged_x_sval);
 
     /* In particular, there should be a constant value for "x".  */
-    ASSERT_EQ (merged_x_sval->get_kind (), svalue2::SK_CONSTANT);
-    ASSERT_EQ (merged_x_sval->dyn_cast_constant_svalue2 ()->get_constant (),
+    ASSERT_EQ (merged_x_sval->get_kind (), svalue::SK_CONSTANT);
+    ASSERT_EQ (merged_x_sval->dyn_cast_constant_svalue ()->get_constant (),
 	       int_42);
   }
 
   /* Two non-equal constant values.  */
   {
-    region_model2 merged (&mgr);
-    const svalue2 *merged_x_sval;
-    assert_region_model2s_merge (x, int_42, int_113, &merged, &merged_x_sval);
+    region_model merged (&mgr);
+    const svalue *merged_x_sval;
+    assert_region_models_merge (x, int_42, int_113, &merged, &merged_x_sval);
 
     /* In particular, there should be an unknown value for "x".  */
     // FIXME
 #if WIDENING
-    ASSERT_EQ (merged_x_sval->get_kind (), svalue2::SK_WIDENING);
+    ASSERT_EQ (merged_x_sval->get_kind (), svalue::SK_WIDENING);
 #else
-    ASSERT_EQ (merged_x_sval->get_kind (), svalue2::SK_UNKNOWN);
+    ASSERT_EQ (merged_x_sval->get_kind (), svalue::SK_UNKNOWN);
 #endif
   }
 
   /* Uninit and constant.  */
   {
-    region_model2 merged (&mgr);
-    const svalue2 *merged_x_sval;
+    region_model merged (&mgr);
+    const svalue *merged_x_sval;
     // FIXME:
 #if 0
-    assert_region_model2s_merge (x, NULL_TREE, int_113, &merged, &merged_x_sval);
+    assert_region_models_merge (x, NULL_TREE, int_113, &merged, &merged_x_sval);
 
     /* In particular, there should be an unknown value for "x".  */
-    ASSERT_EQ (merged_x_sval->get_kind (), svalue2::SK_UNKNOWN);
+    ASSERT_EQ (merged_x_sval->get_kind (), svalue::SK_UNKNOWN);
 #endif
   }
 
   /* Constant and uninit.  */
   {
-    region_model2 merged (&mgr);
-    const svalue2 *merged_x_sval;
+    region_model merged (&mgr);
+    const svalue *merged_x_sval;
     // FIXME:
 #if 0
-    assert_region_model2s_merge (x, int_42, NULL_TREE, &merged, &merged_x_sval);
+    assert_region_models_merge (x, int_42, NULL_TREE, &merged, &merged_x_sval);
 
     /* In particular, there should be an unknown value for "x".  */
-    ASSERT_EQ (merged_x_sval->get_kind (), svalue2::SK_UNKNOWN);
+    ASSERT_EQ (merged_x_sval->get_kind (), svalue::SK_UNKNOWN);
 #endif
   }
 
@@ -10253,66 +8820,66 @@ test_state_merging ()
 
   /* Pointers: non-NULL and non-NULL: ptr to a local.  */
   {
-    region_model2 model0 (&mgr);
+    region_model model0 (&mgr);
     model0.push_frame (DECL_STRUCT_FUNCTION (test_fndecl), NULL, NULL);
     model0.set_value (model0.get_lvalue (p, NULL),
 		      model0.get_rvalue (addr_of_a, NULL), NULL);
 
-    region_model2 model1 (model0);
+    region_model model1 (model0);
     ASSERT_EQ (model0, model1);
 
     /* They should be mergeable, and the result should be the same.  */
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
     ASSERT_EQ (model0, merged);
   }
 
   /* Pointers: non-NULL and non-NULL: ptr to a global.  */
   {
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     /* p == &y in both input models.  */
-    const svalue2 *merged_p_sval;
-    assert_region_model2s_merge (p, addr_of_y, addr_of_y, &merged,
+    const svalue *merged_p_sval;
+    assert_region_models_merge (p, addr_of_y, addr_of_y, &merged,
 				&merged_p_sval);
 
     /* We should get p == &y in the merged model.  */
-    ASSERT_EQ (merged_p_sval->get_kind (), svalue2::SK_REGION);
-    const region_svalue2 *merged_p_ptr
-      = merged_p_sval->dyn_cast_region_svalue2 ();
-    const region2 *merged_p_star_reg = merged_p_ptr->get_pointee ();
+    ASSERT_EQ (merged_p_sval->get_kind (), svalue::SK_REGION);
+    const region_svalue *merged_p_ptr
+      = merged_p_sval->dyn_cast_region_svalue ();
+    const region *merged_p_star_reg = merged_p_ptr->get_pointee ();
     ASSERT_EQ (merged_p_star_reg, merged.get_lvalue (y, NULL));
   }
 
   /* Pointers: non-NULL ptrs to different globals: should be unknown.  */
   {
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     /* x == &y vs x == &z in the input models; these are actually casts
        of the ptrs to "int".  */
-    const svalue2 *merged_x_sval;
+    const svalue *merged_x_sval;
     // TODO:
-    assert_region_model2s_merge (x, addr_of_y, addr_of_z, &merged,
+    assert_region_models_merge (x, addr_of_y, addr_of_z, &merged,
 				&merged_x_sval);
 
     /* We should get x == unknown in the merged model.  */
-    ASSERT_EQ (merged_x_sval->get_kind (), svalue2::SK_UNKNOWN);
+    ASSERT_EQ (merged_x_sval->get_kind (), svalue::SK_UNKNOWN);
   }
 
-  /* Pointers: non-NULL and non-NULL: ptr to a heap region2.  */
+  /* Pointers: non-NULL and non-NULL: ptr to a heap region.  */
   {
-    test_region_model2_context ctxt;
-    region_model2 model0 (&mgr);
+    test_region_model_context ctxt;
+    region_model model0 (&mgr);
     tree size = build_int_cst (integer_type_node, 1024);
-    const svalue2 *size_sval = mgr.get_or_create_constant_svalue2 (size);
-    const region2 *new_reg = model0.create_region_for_heap_alloc (size_sval);
-    const svalue2 *ptr_sval = mgr.get_ptr_svalue2 (ptr_type_node, new_reg);
+    const svalue *size_sval = mgr.get_or_create_constant_svalue (size);
+    const region *new_reg = model0.create_region_for_heap_alloc (size_sval);
+    const svalue *ptr_sval = mgr.get_ptr_svalue (ptr_type_node, new_reg);
     model0.set_value (model0.get_lvalue (p, &ctxt),
 		      ptr_sval, &ctxt);
 
-    region_model2 model1 (model0);
+    region_model model1 (model0);
 
     ASSERT_EQ (model0, model1);
 
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
 
     /* The merged model ought to be identical.  */
@@ -10321,19 +8888,19 @@ test_state_merging ()
 
   // FIXME: uses "set_to_new_unknown_value"
 #if 0
-  /* Two region2s sharing the same unknown svalue2 should continue sharing
-     an unknown svalue2 after self-merger.  */
+  /* Two regions sharing the same unknown svalue should continue sharing
+     an unknown svalue after self-merger.  */
   {
-    test_region_model2_context ctxt;
-    region_model2 model0 (&mgr);
-    const svalue2 *sval
+    test_region_model_context ctxt;
+    region_model model0 (&mgr);
+    const svalue *sval
       = model0.set_to_new_unknown_value (model0.get_lvalue (x, &ctxt),
 					 integer_type_node, &ctxt);
     model0.set_value (model0.get_lvalue (y, &ctxt), sval, &ctxt);
-    region_model2 model1 (model0);
+    region_model model1 (model0);
 
     /* They should be mergeable, and the result should be the same.  */
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
     ASSERT_EQ (model0, merged);
 
@@ -10344,51 +8911,51 @@ test_state_merging ()
 #endif
 
   {
-    region_model2 model0 (&mgr);
-    region_model2 model1 (&mgr);
-    test_region_model2_context ctxt;
+    region_model model0 (&mgr);
+    region_model model1 (&mgr);
+    test_region_model_context ctxt;
     model0.add_constraint (x, EQ_EXPR, int_42, &ctxt);
     model1.add_constraint (x, NE_EXPR, int_42, &ctxt);
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
   }
 
   {
-    region_model2 model0 (&mgr);
-    region_model2 model1 (&mgr);
-    test_region_model2_context ctxt;
+    region_model model0 (&mgr);
+    region_model model1 (&mgr);
+    test_region_model_context ctxt;
     model0.add_constraint (x, EQ_EXPR, int_42, &ctxt);
     model1.add_constraint (x, NE_EXPR, int_42, &ctxt);
     model1.add_constraint (x, EQ_EXPR, int_113, &ctxt);
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
   }
 
   // TODO: what can't we merge? need at least one such test
 
   /* TODO: various things
-     - heap region2s
+     - heap regions
      - value merging:
        - every combination, but in particular
-          - pairs of region2s
+	   - pairs of regions
    */
 
   /* Views.  */
   {
 #if 0
-    test_region_model2_context ctxt;
-    region_model2 model0 (&mgr);
+    test_region_model_context ctxt;
+    region_model model0 (&mgr);
 
-    const region2 *x_reg = model0.get_lvalue (x, &ctxt);
-    const region2 *x_as_ptr = model0.get_or_create_view (x_reg, ptr_type_node,
+    const region *x_reg = model0.get_lvalue (x, &ctxt);
+    const region *x_as_ptr = model0.get_or_create_view (x_reg, ptr_type_node,
 							 &ctxt);
     model0.set_value (x_as_ptr, model0.get_rvalue (addr_of_y, &ctxt), &ctxt);
 
-    region_model2 model1 (model0);
+    region_model model1 (model0);
     ASSERT_EQ (model1, model0);
 
     /* They should be mergeable, and the result should be the same.  */
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
 #endif
   }
@@ -10397,32 +8964,32 @@ test_state_merging ()
      frame points to a local in a more recent stack frame.  */
   {
 #if 0
-    region_model2 model0 (&mgr);
+    region_model model0 (&mgr);
     model0.push_frame (DECL_STRUCT_FUNCTION (test_fndecl), NULL, NULL);
-    const region2 *q_in_first_frame = model0.get_lvalue (q, NULL);
+    const region *q_in_first_frame = model0.get_lvalue (q, NULL);
 
     /* Push a second frame.  */
-    const region2 *reg_2nd_frame
+    const region *reg_2nd_frame
       = model0.push_frame (DECL_STRUCT_FUNCTION (test_fndecl), NULL, NULL);
 
     /* Have a pointer in the older frame point to a local in the
        more recent frame.  */
-    const svalue2 *sval_ptr = model0.get_rvalue (addr_of_a, NULL);
+    const svalue *sval_ptr = model0.get_rvalue (addr_of_a, NULL);
     model0.set_value (q_in_first_frame, sid_ptr, NULL);
 
     /* Verify that it's pointing at the newer frame.  */
-    const region2 *reg_pointee
-      = model0.get_svalue2 (sid_ptr)->dyn_cast_region_svalue2 ()->get_pointee ();
-    ASSERT_EQ (model0.get_region2 (rid_pointee)->get_parent (), rid_2nd_frame);
+    const region *reg_pointee
+      = model0.get_svalue (sid_ptr)->dyn_cast_region_svalue ()->get_pointee ();
+    ASSERT_EQ (model0.get_region (rid_pointee)->get_parent (), rid_2nd_frame);
 
     model0.canonicalize (NULL);
 
-    region_model2 model1 (model0);
+    region_model model1 (model0);
     ASSERT_EQ (model0, model1);
 
     /* They should be mergeable, and the result should be the same
        (after canonicalization, at least).  */
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
     merged.canonicalize (NULL);
     ASSERT_EQ (model0, merged);
@@ -10431,23 +8998,23 @@ test_state_merging ()
 
   /* Verify that we can merge a model in which a local points to a global.  */
   {
-    region_model2 model0 (&mgr);
+    region_model model0 (&mgr);
     model0.push_frame (DECL_STRUCT_FUNCTION (test_fndecl), NULL, NULL);
     model0.set_value (model0.get_lvalue (q, NULL),
 		      model0.get_rvalue (addr_of_y, NULL), NULL);
 
-    region_model2 model1 (model0);
+    region_model model1 (model0);
     ASSERT_EQ (model0, model1);
 
     /* They should be mergeable, and the result should be the same
        (after canonicalization, at least).  */
-    region_model2 merged (&mgr);
+    region_model merged (&mgr);
     ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
     ASSERT_EQ (model0, merged);
   }
 }
 
-/* Verify that constraints are correctly merged when merging region_model2
+/* Verify that constraints are correctly merged when merging region_model
    instances.  */
 
 static void
@@ -10460,17 +9027,17 @@ test_constraint_merging ()
   tree z = build_global_decl ("z", integer_type_node);
   tree n = build_global_decl ("n", integer_type_node);
 
-  region_model2_manager mgr;
-  test_region_model2_context ctxt;
+  region_model_manager mgr;
+  test_region_model_context ctxt;
 
   /* model0: 0 <= (x == y) < n.  */
-  region_model2 model0 (&mgr);
+  region_model model0 (&mgr);
   model0.add_constraint (x, EQ_EXPR, y, &ctxt);
   model0.add_constraint (x, GE_EXPR, int_0, NULL);
   model0.add_constraint (x, LT_EXPR, n, NULL);
 
   /* model1: z != 5 && (0 <= x < n).  */
-  region_model2 model1 (&mgr);
+  region_model model1 (&mgr);
   model1.add_constraint (z, NE_EXPR, int_5, NULL);
   model1.add_constraint (x, GE_EXPR, int_0, NULL);
   model1.add_constraint (x, LT_EXPR, n, NULL);
@@ -10478,7 +9045,7 @@ test_constraint_merging ()
   /* They should be mergeable; the merged constraints should
      be: (0 <= x < n).  */
   program_point point (program_point::origin ());
-  region_model2 merged (&mgr);
+  region_model merged (&mgr);
   ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
 
   ASSERT_EQ (merged.eval_condition (x, GE_EXPR, int_0, &ctxt),
@@ -10502,17 +9069,17 @@ test_widening_constraints ()
   tree int_m1 = build_int_cst (integer_type_node, -1);
   tree int_1 = build_int_cst (integer_type_node, 1);
   tree int_256 = build_int_cst (integer_type_node, 256);
-  region_model2_manager mgr;
-  test_region_model2_context ctxt;
-  const svalue2 *int_0_sval = mgr.get_or_create_constant_svalue2 (int_0);
-  const svalue2 *int_1_sval = mgr.get_or_create_constant_svalue2 (int_1);
-  const svalue2 *w_zero_then_one_sval
-    = mgr.get_or_create_widening_svalue2 (integer_type_node, point,
+  region_model_manager mgr;
+  test_region_model_context ctxt;
+  const svalue *int_0_sval = mgr.get_or_create_constant_svalue (int_0);
+  const svalue *int_1_sval = mgr.get_or_create_constant_svalue (int_1);
+  const svalue *w_zero_then_one_sval
+    = mgr.get_or_create_widening_svalue (integer_type_node, point,
 					  int_0_sval, int_1_sval);
-  const widening_svalue2 *w_zero_then_one
-    = w_zero_then_one_sval->dyn_cast_widening_svalue2 ();
+  const widening_svalue *w_zero_then_one
+    = w_zero_then_one_sval->dyn_cast_widening_svalue ();
   ASSERT_EQ (w_zero_then_one->get_direction (),
-	     widening_svalue2::DIR_ASCENDING);
+	     widening_svalue::DIR_ASCENDING);
   ASSERT_EQ (w_zero_then_one->eval_condition_without_cm (LT_EXPR, int_m1),
 	     tristate::TS_FALSE);
   ASSERT_EQ (w_zero_then_one->eval_condition_without_cm (LT_EXPR, int_0),
@@ -10626,24 +9193,24 @@ test_iteration_1 ()
   tree int_257 = build_int_cst (integer_type_node, 257);
   tree i = build_global_decl ("i", integer_type_node);
 
-  region_model2_manager mgr;
-  test_region_model2_context ctxt;
+  region_model_manager mgr;
+  test_region_model_context ctxt;
 
   /* model0: i: 0.  */
-  region_model2 model0 (&mgr);
+  region_model model0 (&mgr);
   model0.set_value (i, int_0, &ctxt);
 
   /* model1: i: 1.  */
-  region_model2 model1 (&mgr);
+  region_model model1 (&mgr);
   model1.set_value (i, int_1, &ctxt);
 
   /* FIXME: should merge to a widened value.  */
-  region_model2 model2 (&mgr);
+  region_model model2 (&mgr);
   ASSERT_TRUE (model1.can_merge_with_p (model0, point, &model2));
-  const svalue2 *merged_i = model2.get_rvalue (i, &ctxt);
-  ASSERT_EQ (merged_i->get_kind (), svalue2::SK_WIDENING);
-  const widening_svalue2 *w = merged_i->dyn_cast_widening_svalue2 ();
-  ASSERT_EQ (w->get_direction (), widening_svalue2::DIR_ASCENDING);
+  const svalue *merged_i = model2.get_rvalue (i, &ctxt);
+  ASSERT_EQ (merged_i->get_kind (), svalue::SK_WIDENING);
+  const widening_svalue *w = merged_i->dyn_cast_widening_svalue ();
+  ASSERT_EQ (w->get_direction (), widening_svalue::DIR_ASCENDING);
 
   /* Add constraint: i < 256  */
   model2.add_constraint (i, LT_EXPR, int_256, &ctxt);
@@ -10653,7 +9220,7 @@ test_iteration_1 ()
 	     tristate (tristate::TS_TRUE));
 
   /* Try merging with the initial state.  */
-  region_model2 model3 (&mgr);
+  region_model model3 (&mgr);
   ASSERT_TRUE (model2.can_merge_with_p (model0, point, &model3));
   /* Merging the merged value with the initial value should be idempotent,
      so that the analysis converges.  */
@@ -10667,18 +9234,18 @@ test_iteration_1 ()
   ASSERT_EQ (model3, model2);
 
   /* "i_23 = i_11 + 1;"  */
-  region_model2 model4 (model3);
+  region_model model4 (model3);
   ASSERT_EQ (model4, model2);
   model4.set_value (i, build2 (PLUS_EXPR, integer_type_node, i, int_1), &ctxt);
-  const svalue2 *plus_one = model4.get_rvalue (i, &ctxt);
+  const svalue *plus_one = model4.get_rvalue (i, &ctxt);
   /* TODO: what should this be?
      Currently it's the widening(0, +ve) plus one.
      Should it be a new widening(1, +ve), and apply a reworked version
      of the constraints on the other widening value?  */
-  ASSERT_EQ (plus_one->get_kind (), svalue2::SK_BINOP);
+  ASSERT_EQ (plus_one->get_kind (), svalue::SK_BINOP);
 
   /* Try merging with the "i: 1" state.  */
-  region_model2 model5 (&mgr);
+  region_model model5 (&mgr);
   ASSERT_TRUE (model4.can_merge_with_p (model1, point, &model5));
   ASSERT_EQ (model5.get_rvalue (i, &ctxt), plus_one);
   ASSERT_EQ (model5, model4);
@@ -10686,31 +9253,31 @@ test_iteration_1 ()
   /*  "i_11 = PHI();" merge with state at phi above.
       For i, we should have a merger of WIDENING with WIDENING + 1,
       and this should be WIDENING again.  */
-  region_model2 model6 (&mgr);
+  region_model model6 (&mgr);
   ASSERT_TRUE (model5.can_merge_with_p (model2, point, &model6));
-  const svalue2 *merged_widening = model6.get_rvalue (i, &ctxt);
-  ASSERT_EQ (merged_widening->get_kind (), svalue2::SK_WIDENING);
+  const svalue *merged_widening = model6.get_rvalue (i, &ctxt);
+  ASSERT_EQ (merged_widening->get_kind (), svalue::SK_WIDENING);
   // FIXME: what constraints should we have here?
 
-  ASSERT_CONDITION_TRUE2 (model6, i, LT_EXPR, int_257);
+  ASSERT_CONDITION_TRUE (model6, i, LT_EXPR, int_257);
 
   /* This is a cache miss (we have i < 257 rather than i < 256).
      However, on applying the loop-bound condition...
      FIXME.  */
 
-  region_model2 model7_t (model6);
+  region_model model7_t (model6);
   ADD_SAT_CONSTRAINT (model7_t, i, LT_EXPR, int_256);
 
-  region_model2 model7_f (model6);
+  region_model model7_f (model6);
 #if ITERATED_BINOPS
   ADD_SAT_CONSTRAINT (model7_f, i, GE_EXPR, int_256);
-  ASSERT_CONDITION_TRUE2 (model7_f, i, EQ_EXPR, int_256);
+  ASSERT_CONDITION_TRUE (model7_f, i, EQ_EXPR, int_256);
 #endif /* ITERATED_BINOPS */
 
   //ASSERT_EQ (model6, model3);
 
   // TODO: constraints at end of loop (with i >= 256; should get i == 256)
-  /* TODO: unittests for widening_svalue2::eval_condition_without_cm
+  /* TODO: unittests for widening_svalue::eval_condition_without_cm
      (separately).  */
 #endif
 }
@@ -10725,26 +9292,26 @@ test_iteration_2 ()
 
 #if 0
 
-/* Verify that if we mark a pointer to a malloc-ed region2 as non-NULL,
-   all cast pointers to that region2 are also known to be non-NULL.  */
+/* Verify that if we mark a pointer to a malloc-ed region as non-NULL,
+   all cast pointers to that region are also known to be non-NULL.  */
 
 static void
 test_malloc_constraints ()
 {
-  region_model2 model;
+  region_model model;
   tree p = build_global_decl ("p", ptr_type_node);
   tree char_star = build_pointer_type (char_type_node);
   tree q = build_global_decl ("q", char_star);
   tree null_ptr = build_int_cst (ptr_type_node, 0);
 
-  const region2 *reg = model.add_new_malloc_region2 ();
-  const svalue2 *sval = mgr.get_ptr_svalue2 (ptr_type_node, rid);
+  const region *reg = model.add_new_malloc_region ();
+  const svalue *sval = mgr.get_ptr_svalue (ptr_type_node, rid);
   model.set_value (model.get_lvalue (p, NULL), sid, NULL);
   model.set_value (q, p, NULL);
 
-  /* We should have a symbolic_region2 with m_possibly_null: true.  */
-  const region2 *pointee = model.get_region2 (rid);
-  const symbolic_region2 *sym_reg = pointee->dyn_cast_symbolic_region2 ();
+  /* We should have a symbolic_region with m_possibly_null: true.  */
+  const region *pointee = model.get_region (rid);
+  const symbolic_region *sym_reg = pointee->dyn_cast_symbolic_region ();
   ASSERT_NE (sym_reg, NULL);
   ASSERT_TRUE (sym_reg->m_possibly_null);
 
@@ -10774,16 +9341,16 @@ test_var ()
   tree int_17 = build_int_cst (integer_type_node, 17);
   tree int_m3 = build_int_cst (integer_type_node, -3);
 
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
 
-  const region2 *i_reg = model.get_lvalue (i, NULL);
-  ASSERT_EQ (i_reg->get_kind (), region2::RK_DECL);
+  const region *i_reg = model.get_lvalue (i, NULL);
+  ASSERT_EQ (i_reg->get_kind (), region::RK_DECL);
 
   /* Reading "i" should give a symbolic "initial value".  */
-  const svalue2 *sval_init = model.get_rvalue (i, NULL);
-  ASSERT_EQ (sval_init->get_kind (), svalue2::SK_INITIAL);
-  ASSERT_EQ (sval_init->dyn_cast_initial_svalue2 ()->get_region (), i_reg);
+  const svalue *sval_init = model.get_rvalue (i, NULL);
+  ASSERT_EQ (sval_init->get_kind (), svalue::SK_INITIAL);
+  ASSERT_EQ (sval_init->dyn_cast_initial_svalue ()->get_region (), i_reg);
   /* ..and doing it again should give the same "initial value".  */
   ASSERT_EQ (model.get_rvalue (i, NULL), sval_init);
 
@@ -10843,8 +9410,8 @@ test_array ()
   tree int_42 = build_int_cst (integer_type_node, 42);
   tree int_m3 = build_int_cst (integer_type_node, -3);
 
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
   /* "arr[0] = 17;".  */
   model.set_value (arr_0, int_17, NULL);
   /* "arr[1] = -3;".  */
@@ -10859,7 +9426,7 @@ test_array ()
 
   /* Verify get_offset for "arr[0]".  */
   {
-    const region2 *arr_0_reg = model.get_lvalue (arr_0, NULL);
+    const region *arr_0_reg = model.get_lvalue (arr_0, NULL);
     region_offset offset = arr_0_reg->get_offset ();
     ASSERT_EQ (offset.get_base_region (), model.get_lvalue (arr, NULL));
     ASSERT_EQ (offset.get_bit_offset (), 0);
@@ -10867,7 +9434,7 @@ test_array ()
 
   /* Verify get_offset for "arr[1]".  */
   {
-    const region2 *arr_1_reg = model.get_lvalue (arr_1, NULL);
+    const region *arr_1_reg = model.get_lvalue (arr_1, NULL);
     region_offset offset = arr_1_reg->get_offset ();
     ASSERT_EQ (offset.get_base_region (), model.get_lvalue (arr, NULL));
     ASSERT_EQ (offset.get_bit_offset (), INT_TYPE_SIZE);
@@ -10876,12 +9443,12 @@ test_array ()
   /* "arr[i] = i;" - this should remove the earlier bindings.  */
   model.set_value (arr_i, i, NULL);
   ASSERT_EQ (model.get_rvalue (arr_i, NULL), model.get_rvalue (i, NULL));
-  ASSERT_EQ (model.get_rvalue (arr_0, NULL)->get_kind (), svalue2::SK_UNKNOWN);
+  ASSERT_EQ (model.get_rvalue (arr_0, NULL)->get_kind (), svalue::SK_UNKNOWN);
 
   /* "arr[0] = 17;" - this should remove the arr[i] binding.  */
   model.set_value (arr_0, int_17, NULL);
   ASSERT_EQ (model.get_rvalue (arr_0, NULL), model.get_rvalue (int_17, NULL));
-  ASSERT_EQ (model.get_rvalue (arr_i, NULL)->get_kind (), svalue2::SK_UNKNOWN);
+  ASSERT_EQ (model.get_rvalue (arr_i, NULL)->get_kind (), svalue::SK_UNKNOWN);
 }
 
 /* FIXME.  */
@@ -10903,8 +9470,8 @@ test_mem_ref ()
   tree offset_0 = build_int_cst (integer_type_node, 0);
   tree star_p = build2 (MEM_REF, integer_type_node, p, offset_0);
 
-  region_model2_manager mgr;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  region_model model (&mgr);
 
   /* "x = 17;".  */
   model.set_value (x, int_17, NULL);
@@ -10912,7 +9479,7 @@ test_mem_ref ()
   /* "p = &x;".  */
   model.set_value (p, addr_of_x, NULL);
 
-  const svalue2 *sval = model.get_rvalue (star_p, NULL);
+  const svalue *sval = model.get_rvalue (star_p, NULL);
   ASSERT_EQ (sval->maybe_get_constant (), int_17);
 }
 
@@ -10953,10 +9520,10 @@ test_POINTER_PLUS_EXPR_then_MEM_REF ()
   tree offset_0 = build_int_cst (integer_type_node, 0);
   tree mem_ref = build2 (MEM_REF, integer_type_node,
 			 pointer_plus_expr, offset_0);
-  region_model2_manager mgr;
-  region_model2 m (&mgr);
-  const svalue2 *tmp_2 = m.get_rvalue (mem_ref, NULL);
-  const region2 *tmp_5 = m.get_lvalue (mem_ref, NULL);
+  region_model_manager mgr;
+  region_model m (&mgr);
+  const svalue *tmp_2 = m.get_rvalue (mem_ref, NULL);
+  const region *tmp_5 = m.get_lvalue (mem_ref, NULL);
 
   tree int_42 = build_int_cst (integer_type_node, 42);
   m.set_value (mem_ref, int_42, NULL);
@@ -10976,14 +9543,14 @@ test_malloc ()
   tree n_times_4 = build2 (MULT_EXPR, size_type_node,
 			   n, build_int_cst (size_type_node, 4));
 
-  region_model2_manager mgr;
-  test_region_model2_context ctxt;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  test_region_model_context ctxt;
+  region_model model (&mgr);
 
   /* "p = malloc (n * 4);".  */
-  const svalue2 *size_sval = model.get_rvalue (n_times_4, &ctxt);
-  const region2 *reg = model.create_region_for_heap_alloc (size_sval);
-  const svalue2 *ptr = mgr.get_ptr_svalue2 (int_star, reg);
+  const svalue *size_sval = model.get_rvalue (n_times_4, &ctxt);
+  const region *reg = model.create_region_for_heap_alloc (size_sval);
+  const svalue *ptr = mgr.get_ptr_svalue (int_star, reg);
   model.set_value (model.get_lvalue (p, &ctxt), ptr, &ctxt);
   // TODO: verify dynamic extents
 
@@ -11007,26 +9574,26 @@ test_alloca ()
   tree n_times_4 = build2 (MULT_EXPR, size_type_node,
 			   n, build_int_cst (size_type_node, 4));
 
-  region_model2_manager mgr;
-  test_region_model2_context ctxt;
-  region_model2 model (&mgr);
+  region_model_manager mgr;
+  test_region_model_context ctxt;
+  region_model model (&mgr);
 
   /* Push stack frame.  */
-  const region2 *frame_reg
+  const region *frame_reg
     = model.push_frame (DECL_STRUCT_FUNCTION (fndecl),
 			NULL, &ctxt);
   /* "p = alloca (n * 4);".  */
-  const svalue2 *size_sval = model.get_rvalue (n_times_4, &ctxt);
-  const region2 *reg = model.create_region_for_alloca (size_sval);
-  const svalue2 *ptr = mgr.get_ptr_svalue2 (int_star, reg);
+  const svalue *size_sval = model.get_rvalue (n_times_4, &ctxt);
+  const region *reg = model.create_region_for_alloca (size_sval);
+  const svalue *ptr = mgr.get_ptr_svalue (int_star, reg);
   model.set_value (model.get_lvalue (p, &ctxt), ptr, &ctxt);
   // TODO: verify dynamic extents
 
   /* Verify that the pointers to the alloca region are replaced by
      poisoned values when the frame is popped.  */
-  purge_stats2 purged;
+  purge_stats purged;
   model.pop_frame (NULL, true, &purged, NULL, &ctxt);
-  ASSERT_EQ (model.get_rvalue (p, &ctxt)->get_kind (), svalue2::SK_POISONED);
+  ASSERT_EQ (model.get_rvalue (p, &ctxt)->get_kind (), svalue::SK_POISONED);
 }
 
 /* Run all of the selftests within this file.  */
@@ -11044,17 +9611,17 @@ analyzer_region_model_cc_tests ()
   test_unique_constants ();
   test_unique_unknowns ();
 #if 0
-  test_svalue2_equality ();
-  test_region2_equality ();
+  test_svalue_equality ();
+  test_region_equality ();
 #endif
-  test_initial_svalue2_folding ();
-  test_unaryop_svalue2_folding ();
-  test_binop_svalue2_folding ();
-  test_sub_svalue2_folding ();
+  test_initial_svalue_folding ();
+  test_unaryop_svalue_folding ();
+  test_binop_svalue_folding ();
+  test_sub_svalue_folding ();
   test_descendent_of_p ();
 #if 0
   test_purging_by_criteria ();
-  test_purge_unused_svalue2s ();
+  test_purge_unused_svalues ();
 #endif
   test_assignment ();
   test_compound_assignment ();
diff --git a/gcc/analyzer/region-model.h b/gcc/analyzer/region-model.h
index e5d04b47e0d..f75625fbe48 100644
--- a/gcc/analyzer/region-model.h
+++ b/gcc/analyzer/region-model.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_REGION_MODEL_2_H
-#define GCC_ANALYZER_REGION_MODEL_2_H
+#ifndef GCC_ANALYZER_REGION_MODEL_H
+#define GCC_ANALYZER_REGION_MODEL_H
 
 #include "analyzer/uniq-manager.h" // FIXME
 #include "analyzer/store.h" // FIXME
@@ -39,7 +39,7 @@ along with GCC; see the file COPYING3.  If not see
    - no region_id or svalue_id, just pointers.
    - regions are shared throughout the analysis, via a region_manager.
    - should svalues also be shared?  Probably
-   - regions and values don't have state; region_model2 instances do
+   - regions and values don't have state; region_model instances do
      (though potentially we want to use the regions to store information
      about the shared region structure e.g. subregions of map_region)
    - no canonicalization or ID remapping should be needed
@@ -48,10 +48,10 @@ along with GCC; see the file COPYING3.  If not see
      uniquifying?)
    - not yet sure if we need validation
    - the concept of what the "current stack" is needs to move from the
-     regions to the region_model2 (maybe a region *m_current_frame)
+     regions to the region_model (maybe a region *m_current_frame)
    - do we still need region cloning?
    - should there still be a root_region?  or should those things go in the
-     ext_state (or something owned by ext_state: region_model2_manager)
+     ext_state (or something owned by ext_state: region_model_manager)
    Hopefully this is a huge simplification, and (I hope) avoids lots of heap
    churn as states are copied.
 
@@ -95,19 +95,19 @@ struct member_function_hash_traits : public typed_noop_remove<Type>
   static inline bool is_empty (Type t) { return t.is_empty (); }
 };
 
-/* A region_model2 is effectively a graph of regions and symbolic values.
+/* A region_model is effectively a graph of regions and symbolic values.
    FIXME: we're eliminating IDs in this prototype.
    We store per-model IDs rather than pointers to make it easier to clone
    and to compare graphs.  */
 
-/* Various operations delete information from a region_model2.
+/* Various operations delete information from a region_model.
 
    This struct tracks how many of each kind of entity were purged (e.g.
    for selftests, and for debugging).  */
 
-struct purge_stats2
+struct purge_stats
 {
-  purge_stats2 ()
+  purge_stats ()
   : m_num_svalues (0),
     m_num_regions (0),
     m_num_equiv_classes (0),
@@ -122,7 +122,7 @@ struct purge_stats2
   int m_num_client_items;
 };
 
-/* A measurement of the complexity of an svalue2 or region2, so that
+/* A measurement of the complexity of an svalue or region, so that
    we can avoid these tree-like structures growing without bounds and
    thus leading to infinite chains of analysis.  */
 
@@ -132,11 +132,11 @@ struct complexity
   : m_num_nodes (num_nodes), m_max_depth (max_depth)
   {}
 
-  complexity (const region2 *reg);
-  complexity (const svalue2 *sval);
-  static complexity from_pair (const complexity &c1, const complexity &c2);
+  complexity (const region *reg);
+  complexity (const svalue *sval);
+  static complexity from_pair (const complexity &c1, const complexity &c);
 
-  /* The total number of svalue2s and region2s in the tree of this
+  /* The total number of svalues and regions in the tree of this
      entity, including the entity itself.  */
   unsigned m_num_nodes;
 
@@ -148,22 +148,22 @@ struct complexity
 class visitor
 {
 public:
-  virtual void visit_region_svalue2 (const region_svalue2 *) {}
-  virtual void visit_constant_svalue2 (const constant_svalue2 *) {}
-  virtual void visit_unknown_svalue2 (const unknown_svalue2 *) {}
-  virtual void visit_poisoned_svalue2 (const poisoned_svalue2 *) {}
-  virtual void visit_setjmp_svalue2 (const setjmp_svalue2 *) {}
-  virtual void visit_initial_svalue2 (const initial_svalue2 *) {}
-  virtual void visit_unaryop_svalue2 (const unaryop_svalue2 *) {}
-  virtual void visit_binop_svalue2 (const binop_svalue2 *) {}
-  virtual void visit_sub_svalue2 (const sub_svalue2 *) {}
-  virtual void visit_unmergeable_svalue2 (const unmergeable_svalue2 *) {}
-  virtual void visit_placeholder_svalue2 (const placeholder_svalue2 *) {}
-  virtual void visit_widening_svalue2 (const widening_svalue2 *) {}
-  virtual void visit_compound_svalue2 (const compound_svalue2 *) {}
-  virtual void visit_conjured_svalue2 (const conjured_svalue2 *) {}
-
-  virtual void visit_region (const region2 *) {}
+  virtual void visit_region_svalue (const region_svalue *) {}
+  virtual void visit_constant_svalue (const constant_svalue *) {}
+  virtual void visit_unknown_svalue (const unknown_svalue *) {}
+  virtual void visit_poisoned_svalue (const poisoned_svalue *) {}
+  virtual void visit_setjmp_svalue (const setjmp_svalue *) {}
+  virtual void visit_initial_svalue (const initial_svalue *) {}
+  virtual void visit_unaryop_svalue (const unaryop_svalue *) {}
+  virtual void visit_binop_svalue (const binop_svalue *) {}
+  virtual void visit_sub_svalue (const sub_svalue *) {}
+  virtual void visit_unmergeable_svalue (const unmergeable_svalue *) {}
+  virtual void visit_placeholder_svalue (const placeholder_svalue *) {}
+  virtual void visit_widening_svalue (const widening_svalue *) {}
+  virtual void visit_compound_svalue (const compound_svalue *) {}
+  virtual void visit_conjured_svalue (const conjured_svalue *) {}
+
+  virtual void visit_region (const region *) {}
 };
 
 /* svalue and its subclasses.
@@ -171,27 +171,27 @@ public:
    The class hierarchy looks like this (using indentation to show
    inheritance, and with kinds shown for the concrete subclasses):
 
-   svalue2
-     region_svalue2 (SK_REGION): a pointer to a region2
-     constant_svalue2 (SK_CONSTANT): a constant
-     unknown_svalue2 (SK_UNKNOWN): an unknowable value
-     poisoned_svalue2 (SK_POISONED): a unusable value (undefined)
-     setjmp_svalue2 (SK_SETJMP): a setjmp/longjmp buffer
-     initial2_svalue2 (SK_INITIAL): the initial value of a region2
-     unaryop_svalue2 (SK_UNARYOP): unary operation on another svalue2
-     binop_svalue2 (SK_BINOP): binary operation on two svalue2s
-     sub_svalue2 (SK_SUB): the result of accessing a subregion
-     unmergeable_svalue2 (SK_UNMERGEABLE): a value that is so interesting
+   svalue
+     region_svalue (SK_REGION): a pointer to a region
+     constant_svalue (SK_CONSTANT): a constant
+     unknown_svalue (SK_UNKNOWN): an unknowable value
+     poisoned_svalue (SK_POISONED): a unusable value (undefined)
+     setjmp_svalue (SK_SETJMP): a setjmp/longjmp buffer
+     initial_svalue (SK_INITIAL): the initial value of a region
+     unaryop_svalue (SK_UNARYOP): unary operation on another svalue
+     binop_svalue (SK_BINOP): binary operation on two svalues
+     sub_svalue (SK_SUB): the result of accessing a subregion
+     unmergeable_svalue (SK_UNMERGEABLE): a value that is so interesting
        from a control-flow perspective that it can inhibit state-merging
-     placeholder_svalue2 (SK_PLACEHOLDER): for use in selftests.
-     widening_svalue2 (SK_WIDENING): a merger of two svalues (possibly
+     placeholder_svalue (SK_PLACEHOLDER): for use in selftests.
+     widening_svalue (SK_WIDENING): a merger of two svalues (possibly
        in an iteration).
-     compound_svalue2 (SK_COMPOUND): a mapping of bit-ranges to svalues
-     conjured_svalue2 (SK_CONJURED): a value arising from a stmt.  */
+     compound_svalue (SK_COMPOUND): a mapping of bit-ranges to svalues
+     conjured_svalue (SK_CONJURED): a value arising from a stmt.  */
 
 /* An abstract base class representing a value held by a region of memory.  */
 
-class svalue2
+class svalue
 {
 public:
   /* An enum for discriminating between the different concrete subclasses
@@ -214,22 +214,22 @@ public:
    SK_CONJURED
   };
 
-  virtual ~svalue2 () {}
+  virtual ~svalue () {}
 
 #if 0
-  bool operator== (const svalue2 &other) const;
-  bool operator!= (const svalue2 &other) const { return !(*this == other); }
+  bool operator== (const svalue &other) const;
+  bool operator!= (const svalue &other) const { return !(*this == other); }
 #endif
 
   tree get_type () const { return m_type; }
 
   virtual enum kind get_kind () const = 0;
 
-  void print (const region_model2 &model,
+  void print (const region_model &model,
 	      pretty_printer *pp) const;
 
 #if 0
-  virtual void dump_dot_to_pp (const region_model2 &model,
+  virtual void dump_dot_to_pp (const region_model &model,
 			       pretty_printer *pp) const;
 #endif
 
@@ -237,50 +237,50 @@ public:
   void dump (bool simple=true) const;
   label_text get_desc (bool simple=true) const;
 
-  virtual const region_svalue2 *
-  dyn_cast_region_svalue2 () const { return NULL; }
-  virtual const constant_svalue2 *
-  dyn_cast_constant_svalue2 () const { return NULL; }
-  virtual const poisoned_svalue2 *
-  dyn_cast_poisoned_svalue2 () const { return NULL; }
-  virtual const setjmp_svalue2 *
-  dyn_cast_setjmp_svalue2 () const { return NULL; }
-  virtual const initial_svalue2 *
-  dyn_cast_initial_svalue2 () const { return NULL; }
-  virtual const unaryop_svalue2 *
-  dyn_cast_unaryop_svalue2 () const { return NULL; }
-  virtual const binop_svalue2 *
-  dyn_cast_binop_svalue2 () const { return NULL; }
-  virtual const sub_svalue2 *
-  dyn_cast_sub_svalue2 () const { return NULL; }
-  virtual const unmergeable_svalue2 *
-  dyn_cast_unmergeable_svalue2 () const { return NULL; }
-  virtual const widening_svalue2 *
-  dyn_cast_widening_svalue2 () const { return NULL; }
-  virtual const compound_svalue2 *
-  dyn_cast_compound_svalue2 () const { return NULL; }
-  virtual const conjured_svalue2 *
-  dyn_cast_conjured_svalue2 () const { return NULL; }
+  virtual const region_svalue *
+  dyn_cast_region_svalue () const { return NULL; }
+  virtual const constant_svalue *
+  dyn_cast_constant_svalue () const { return NULL; }
+  virtual const poisoned_svalue *
+  dyn_cast_poisoned_svalue () const { return NULL; }
+  virtual const setjmp_svalue *
+  dyn_cast_setjmp_svalue () const { return NULL; }
+  virtual const initial_svalue *
+  dyn_cast_initial_svalue () const { return NULL; }
+  virtual const unaryop_svalue *
+  dyn_cast_unaryop_svalue () const { return NULL; }
+  virtual const binop_svalue *
+  dyn_cast_binop_svalue () const { return NULL; }
+  virtual const sub_svalue *
+  dyn_cast_sub_svalue () const { return NULL; }
+  virtual const unmergeable_svalue *
+  dyn_cast_unmergeable_svalue () const { return NULL; }
+  virtual const widening_svalue *
+  dyn_cast_widening_svalue () const { return NULL; }
+  virtual const compound_svalue *
+  dyn_cast_compound_svalue () const { return NULL; }
+  virtual const conjured_svalue *
+  dyn_cast_conjured_svalue () const { return NULL; }
 
   tree maybe_get_constant () const;
-  const svalue2 *maybe_undo_cast () const;
-  const svalue2 *unwrap_any_unmergeable () const;
+  const svalue *maybe_undo_cast () const;
+  const svalue *unwrap_any_unmergeable () const;
 
-  const svalue2 *can_merge_p (const svalue2 *other,
-			      region_model2_manager *mgr,
-			      model2_merger *merger) const;
+  const svalue *can_merge_p (const svalue *other,
+			      region_model_manager *mgr,
+			      model_merger *merger) const;
 
   const complexity &get_complexity () const { return m_complexity; }
 
   virtual void accept (visitor *v) const  = 0;
 
-  bool live_p (const svalue2_set &live_svalues,
-	       const region_model2 *model) const;
-  virtual bool implicitly_live_p (const svalue2_set &live_svalues,
-				  const region_model2 *model) const;
+  bool live_p (const svalue_set &live_svalues,
+	       const region_model *model) const;
+  virtual bool implicitly_live_p (const svalue_set &live_svalues,
+				  const region_model *model) const;
 
  protected:
-  svalue2 (complexity c, tree type)
+  svalue (complexity c, tree type)
   : m_complexity (c), m_type (type)
   {}
 
@@ -289,14 +289,14 @@ public:
   tree m_type;
 };
 
-/* Concrete subclass of svalue2 representing a pointer value that points to
+/* Concrete subclass of svalue representing a pointer value that points to
    a known region  */
 
-class region_svalue2 : public svalue2
+class region_svalue : public svalue
 {
 public:
-  region_svalue2 (tree type, const region2 *reg)
-  : svalue2 (complexity (reg), type),
+  region_svalue (tree type, const region *reg)
+  : svalue (complexity (reg), type),
     m_reg (reg)
   {
     gcc_assert (m_reg != NULL);
@@ -305,34 +305,26 @@ public:
   enum kind get_kind () const FINAL OVERRIDE { return SK_REGION; }
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const region_svalue2 *
-  dyn_cast_region_svalue2 () const FINAL OVERRIDE { return this; }
+  const region_svalue *
+  dyn_cast_region_svalue () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
-  const region2 * get_pointee () const { return m_reg; }
+  const region * get_pointee () const { return m_reg; }
 
-#if 0
-  static void merge_values (const region_svalue2 &region_sval_a,
-			    const region_svalue2 &region_sval_b,
-			    svalue2_id *merged_sid,
-			    tree type,
-			    model_merger *merger);
-#endif
-
-  static tristate eval_condition (const region_svalue2 *lhs_ptr,
+  static tristate eval_condition (const region_svalue *lhs_ptr,
 				  enum tree_code op,
-				  const region_svalue2 *rhs_ptr);
+				  const region_svalue *rhs_ptr);
 
  private:
-  const region2 *m_reg;
+  const region *m_reg;
 };
 
 } // namespace ana
@@ -340,20 +332,20 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const region_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const region_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_REGION;
+  return sval->get_kind () == svalue::SK_REGION;
 }
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing a specific constant value.  */
+/* Concrete subclass of svalue representing a specific constant value.  */
 
-class constant_svalue2 : public svalue2
+class constant_svalue : public svalue
 {
 public:
-  constant_svalue2 (tree cst_expr)
-  : svalue2 (complexity (1, 1), TREE_TYPE (cst_expr)), m_cst_expr (cst_expr)
+  constant_svalue (tree cst_expr)
+  : svalue (complexity (1, 1), TREE_TYPE (cst_expr)), m_cst_expr (cst_expr)
   {
     gcc_assert (cst_expr);
     gcc_assert (CONSTANT_CLASS_P (cst_expr));
@@ -362,26 +354,19 @@ public:
   enum kind get_kind () const FINAL OVERRIDE { return SK_CONSTANT; }
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const constant_svalue2 *
-  dyn_cast_constant_svalue2 () const FINAL OVERRIDE { return this; }
+  const constant_svalue *
+  dyn_cast_constant_svalue () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
-  bool implicitly_live_p (const svalue2_set &,
-			  const region_model2 *) const FINAL OVERRIDE;
+  bool implicitly_live_p (const svalue_set &,
+			  const region_model *) const FINAL OVERRIDE;
 
   tree get_constant () const { return m_cst_expr; }
 
-#if 0
-  static void merge_values (const constant_svalue2 &cst_sval_a,
-			    const constant_svalue2 &cst_sval_b,
-			    svalue2_id *merged_sid,
-			    model_merger *merger);
-#endif
-
-  static tristate eval_condition (const constant_svalue2 *lhs,
+  static tristate eval_condition (const constant_svalue *lhs,
 				  enum tree_code op,
-				  const constant_svalue2 *rhs);
+				  const constant_svalue *rhs);
 
  private:
   tree m_cst_expr;
@@ -392,23 +377,23 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const constant_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const constant_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_CONSTANT;
+  return sval->get_kind () == svalue::SK_CONSTANT;
 }
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing an unknowable value, the bottom
-   value when thinking of svalue2s as a lattice.
-   This is a singleton (w.r.t. its manager): there is a single unknown_svalue2
+/* Concrete subclass of svalue representing an unknowable value, the bottom
+   value when thinking of svalues as a lattice.
+   This is a singleton (w.r.t. its manager): there is a single unknown_svalue
    per type.  Self-comparisons of such instances yield "unknown".  */
 
-class unknown_svalue2 : public svalue2
+class unknown_svalue : public svalue
 {
 public:
-  unknown_svalue2 (tree type)
-  : svalue2 (complexity (1, 1), type)
+  unknown_svalue (tree type)
+  : svalue (complexity (1, 1), type)
   {}
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_UNKNOWN; }
@@ -434,13 +419,13 @@ enum poison_kind
 
 extern const char *poison_kind_to_str (enum poison_kind);
 
-/* Concrete subclass of svalue2 representing a value that should not
+/* Concrete subclass of svalue representing a value that should not
    be used (e.g. uninitialized memory, freed memory).  */
 
-class poisoned_svalue2 : public svalue2
+class poisoned_svalue : public svalue
 {
 public:
-  /* A support class for uniquifying instances of poisoned_svalue2.  */
+  /* A support class for uniquifying instances of poisoned_svalue.  */
   struct key_t
   {
     key_t (enum poison_kind kind, tree type)
@@ -469,14 +454,14 @@ public:
     tree m_type;
   };
 
-  poisoned_svalue2 (enum poison_kind kind, tree type)
-  : svalue2 (complexity (1, 1), type), m_kind (kind) {}
+  poisoned_svalue (enum poison_kind kind, tree type)
+  : svalue (complexity (1, 1), type), m_kind (kind) {}
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_POISONED; }
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const poisoned_svalue2 *
-  dyn_cast_poisoned_svalue2 () const FINAL OVERRIDE { return this; }
+  const poisoned_svalue *
+  dyn_cast_poisoned_svalue () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
@@ -491,27 +476,27 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const poisoned_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const poisoned_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_POISONED;
+  return sval->get_kind () == svalue::SK_POISONED;
 }
 
-template <> struct default_hash_traits<poisoned_svalue2::key_t>
-: public member_function_hash_traits<poisoned_svalue2::key_t>
+template <> struct default_hash_traits<poisoned_svalue::key_t>
+: public member_function_hash_traits<poisoned_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing buffers for setjmp/sigsetjmp,
+/* Concrete subclass of svalue representing buffers for setjmp/sigsetjmp,
    so that longjmp/siglongjmp can potentially "return" to an entirely
    different function.  */
 
-class setjmp_svalue2 : public svalue2
+class setjmp_svalue : public svalue
 {
 public:
-  /* A support class for uniquifying instances of poisoned_svalue2.  */
+  /* A support class for uniquifying instances of poisoned_svalue.  */
   struct key_t
   {
     key_t (const setjmp_record &record, tree type)
@@ -540,16 +525,16 @@ public:
     tree m_type;
   };
 
-  setjmp_svalue2 (const setjmp_record &setjmp_record,
+  setjmp_svalue (const setjmp_record &setjmp_record,
 		  tree type)
-  : svalue2 (complexity (1, 1), type), m_setjmp_record (setjmp_record)
+  : svalue (complexity (1, 1), type), m_setjmp_record (setjmp_record)
   {}
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_SETJMP; }
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const setjmp_svalue2 *
-  dyn_cast_setjmp_svalue2 () const FINAL OVERRIDE { return this; }
+  const setjmp_svalue *
+  dyn_cast_setjmp_svalue () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
@@ -566,20 +551,20 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const setjmp_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const setjmp_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_SETJMP;
+  return sval->get_kind () == svalue::SK_SETJMP;
 }
 
-template <> struct default_hash_traits<setjmp_svalue2::key_t>
-: public member_function_hash_traits<setjmp_svalue2::key_t>
+template <> struct default_hash_traits<setjmp_svalue::key_t>
+: public member_function_hash_traits<setjmp_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing the initial value of a
+/* Concrete subclass of svalue representing the initial value of a
    specific region.
 
    FIXME: trying this approach:
@@ -588,11 +573,11 @@ namespace ana {
    Hence as soon as we have a call to an unknown function, all previously
    unmodelled globals become implicitly "unknown" rathen than "initial".  */
 
-class initial_svalue2 : public svalue2
+class initial_svalue : public svalue
 {
 public:
-  initial_svalue2 (tree type, const region2 *reg)
-  : svalue2 (complexity (reg), type), m_reg (reg)
+  initial_svalue (tree type, const region *reg)
+  : svalue (complexity (reg), type), m_reg (reg)
   {
     gcc_assert (m_reg != NULL);
   }
@@ -600,33 +585,25 @@ public:
   enum kind get_kind () const FINAL OVERRIDE { return SK_INITIAL; }
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const initial_svalue2 *
-  dyn_cast_initial_svalue2 () const FINAL OVERRIDE { return this; }
+  const initial_svalue *
+  dyn_cast_initial_svalue () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
-  bool implicitly_live_p (const svalue2_set &,
-			  const region_model2 *) const FINAL OVERRIDE;
+  bool implicitly_live_p (const svalue_set &,
+			  const region_model *) const FINAL OVERRIDE;
 
-  const region2 * get_region () const { return m_reg; }
-
-#if 0
-  static void merge_values (const initial_svalue2 &region_sval_a,
-			    const initial_svalue2 &region_sval_b,
-			    svalue2_id *merged_sid,
-			    tree type,
-			    model_merger *merger);
-#endif
+  const region * get_region () const { return m_reg; }
 
  private:
-  const region2 *m_reg;
+  const region *m_reg;
 };
 
 } // namespace ana
@@ -634,23 +611,23 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const initial_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const initial_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_INITIAL;
+  return sval->get_kind () == svalue::SK_INITIAL;
 }
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing a unary operation on
-   another svalue2s (e.g. a cast).  */
+/* Concrete subclass of svalue representing a unary operation on
+   another svalues (e.g. a cast).  */
 
-class unaryop_svalue2 : public svalue2
+class unaryop_svalue : public svalue
 {
 public:
-  /* A support class for uniquifying instances of unaryop_svalue2.  */
+  /* A support class for uniquifying instances of unaryop_svalue.  */
   struct key_t
   {
-    key_t (tree type, enum tree_code op, const svalue2 *arg)
+    key_t (tree type, enum tree_code op, const svalue *arg)
     : m_type (type), m_op (op), m_arg (arg)
     {}
 
@@ -677,25 +654,25 @@ public:
 
     tree m_type;
     enum tree_code m_op;
-    const svalue2 *m_arg;
+    const svalue *m_arg;
   };
 
-  unaryop_svalue2 (tree type, enum tree_code op, const svalue2 *arg)
-  : svalue2 (complexity (arg), type), m_op (op), m_arg (arg)
+  unaryop_svalue (tree type, enum tree_code op, const svalue *arg)
+  : svalue (complexity (arg), type), m_op (op), m_arg (arg)
   {
   }
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_UNARYOP; }
-  const unaryop_svalue2 *
-  dyn_cast_unaryop_svalue2 () const FINAL OVERRIDE { return this; }
+  const unaryop_svalue *
+  dyn_cast_unaryop_svalue () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
-  bool implicitly_live_p (const svalue2_set &,
-			  const region_model2 *) const FINAL OVERRIDE;
+  bool implicitly_live_p (const svalue_set &,
+			  const region_model *) const FINAL OVERRIDE;
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
@@ -704,11 +681,11 @@ public:
 
 
   enum tree_code get_op () const { return m_op; }
-  const svalue2 *get_arg () const { return m_arg; }
+  const svalue *get_arg () const { return m_arg; }
 
  private:
   enum tree_code m_op;
-  const svalue2 *m_arg;
+  const svalue *m_arg;
 };
 
 } // namespace ana
@@ -716,30 +693,30 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const unaryop_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const unaryop_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_UNARYOP;
+  return sval->get_kind () == svalue::SK_UNARYOP;
 }
 
-template <> struct default_hash_traits<unaryop_svalue2::key_t>
-: public member_function_hash_traits<unaryop_svalue2::key_t>
+template <> struct default_hash_traits<unaryop_svalue::key_t>
+: public member_function_hash_traits<unaryop_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing a binary operation of
-   two svalue2s.  */
+/* Concrete subclass of svalue representing a binary operation of
+   two svalues.  */
 
-class binop_svalue2 : public svalue2
+class binop_svalue : public svalue
 {
 public:
-  /* A support class for uniquifying instances of binop_svalue2.  */
+  /* A support class for uniquifying instances of binop_svalue.  */
   struct key_t
   {
     key_t (tree type, enum tree_code op,
-	   const svalue2 *arg0, const svalue2 *arg1)
+	   const svalue *arg0, const svalue *arg1)
     : m_type (type), m_op (op), m_arg0 (arg0), m_arg1 (arg1)
     {}
 
@@ -768,13 +745,13 @@ public:
 
     tree m_type;
     enum tree_code m_op;
-    const svalue2 *m_arg0;
-    const svalue2 *m_arg1;
+    const svalue *m_arg0;
+    const svalue *m_arg1;
   };
 
-  binop_svalue2 (tree type, enum tree_code op,
-		 const svalue2 *arg0, const svalue2 *arg1)
-  : svalue2 (complexity::from_pair (arg0->get_complexity (),
+  binop_svalue (tree type, enum tree_code op,
+		 const svalue *arg0, const svalue *arg1)
+  : svalue (complexity::from_pair (arg0->get_complexity (),
 				    arg1->get_complexity ()),
 	     type),
     m_op (op), m_arg0 (arg0), m_arg1 (arg1)
@@ -782,19 +759,19 @@ public:
   }
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_BINOP; }
-  virtual const binop_svalue2 *dyn_cast_binop_svalue2 () const { return this; }
+  virtual const binop_svalue *dyn_cast_binop_svalue () const { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
-  bool implicitly_live_p (const svalue2_set &,
-			  const region_model2 *) const FINAL OVERRIDE;
+  bool implicitly_live_p (const svalue_set &,
+			  const region_model *) const FINAL OVERRIDE;
 
   enum tree_code get_op () const { return m_op; }
-  const svalue2 *get_arg0 () const { return m_arg0; }
-  const svalue2 *get_arg1 () const { return m_arg1; }
+  const svalue *get_arg0 () const { return m_arg0; }
+  const svalue *get_arg1 () const { return m_arg1; }
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
@@ -802,14 +779,14 @@ public:
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
 #if 0
-  const binop_svalue2 *
-  dyn_cast_binop_svalue2 () const FINAL OVERRIDE { return this; }
+  const binop_svalue *
+  dyn_cast_binop_svalue () const FINAL OVERRIDE { return this; }
 #endif
 
  private:
   enum tree_code m_op;
-  const svalue2 *m_arg0;
-  const svalue2 *m_arg1;
+  const svalue *m_arg0;
+  const svalue *m_arg1;
 };
 
 } // namespace ana
@@ -817,31 +794,31 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const binop_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const binop_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_BINOP;
+  return sval->get_kind () == svalue::SK_BINOP;
 }
 
-template <> struct default_hash_traits<binop_svalue2::key_t>
-: public member_function_hash_traits<binop_svalue2::key_t>
+template <> struct default_hash_traits<binop_svalue::key_t>
+: public member_function_hash_traits<binop_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing the result of accessing a subregion
-   of another svalue2 (the value of a component/field of a struct, or an element
+/* Concrete subclass of svalue representing the result of accessing a subregion
+   of another svalue (the value of a component/field of a struct, or an element
    from an array).
    FIXME: do we want to split this into two different classes for that?  */
 
-class sub_svalue2 : public svalue2
+class sub_svalue : public svalue
 {
 public:
-  /* A support class for uniquifying instances of sub_svalue2.  */
+  /* A support class for uniquifying instances of sub_svalue.  */
   struct key_t
   {
-    key_t (tree type, const svalue2 *parent_svalue, const region2 *subregion)
+    key_t (tree type, const svalue *parent_svalue, const region *subregion)
     : m_type (type), m_parent_svalue (parent_svalue), m_subregion (subregion)
     {}
 
@@ -867,35 +844,35 @@ public:
     bool is_empty () const { return m_type == NULL_TREE; }
 
     tree m_type;
-    const svalue2 *m_parent_svalue;
-    const region2 *m_subregion;
+    const svalue *m_parent_svalue;
+    const region *m_subregion;
   };
-  sub_svalue2 (tree type, const svalue2 *parent_svalue,
-	       const region2 *subregion);
+  sub_svalue (tree type, const svalue *parent_svalue,
+	       const region *subregion);
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_SUB; }
-  const sub_svalue2 *dyn_cast_sub_svalue2 () const FINAL OVERRIDE
+  const sub_svalue *dyn_cast_sub_svalue () const FINAL OVERRIDE
   {
     return this;
   }
   void accept (visitor *v) const FINAL OVERRIDE;
-  bool implicitly_live_p (const svalue2_set &,
-			  const region_model2 *) const FINAL OVERRIDE;
+  bool implicitly_live_p (const svalue_set &,
+			  const region_model *) const FINAL OVERRIDE;
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const svalue2 *get_parent () const { return m_parent_svalue; }
-  const region2 *get_subregion () const { return m_subregion; }
+  const svalue *get_parent () const { return m_parent_svalue; }
+  const region *get_subregion () const { return m_subregion; }
 
  private:
-  const svalue2 *m_parent_svalue;
-  const region2 *m_subregion;
+  const svalue *m_parent_svalue;
+  const region *m_subregion;
 };
 
 } // namespace ana
@@ -903,30 +880,30 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const sub_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const sub_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_SUB;
+  return sval->get_kind () == svalue::SK_SUB;
 }
 
-template <> struct default_hash_traits<sub_svalue2::key_t>
-: public member_function_hash_traits<sub_svalue2::key_t>
+template <> struct default_hash_traits<sub_svalue::key_t>
+: public member_function_hash_traits<sub_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
 
 namespace ana {
 
-/* Concrete subclass of svalue2: decorate another svalue2,
-   so that the resulting svalue2 can be identified as being
+/* Concrete subclass of svalue: decorate another svalue,
+   so that the resulting svalue can be identified as being
    "interesting to control flow".
    For example, consider the return value from setjmp.  We
    don't want to merge states in which the result is 0 with
    those in which the result is non-zero.  By using an
-   unmergeable_svalue2 for the result, we can inhibit such merges
+   unmergeable_svalue for the result, we can inhibit such merges
    and have separate exploded nodes for those states, keeping
    the first and second returns from setjmp distinct in the exploded
    graph.
-   FIXME: possibly rename to "significant_svalue2"?
+   FIXME: possibly rename to "significant_svalue"?
    FIXME: possibly use this to capture "significant" conditions in
    control flow, and to use this to tweak descriptions of conditions
    in paths.  Specifically, could this be used by
@@ -935,33 +912,33 @@ namespace ana {
      following 'true' branch (when value returned from 'setjmp' is non-zero)
    or somesuch.  */
 
-class unmergeable_svalue2 : public svalue2
+class unmergeable_svalue : public svalue
 {
 public:
-  unmergeable_svalue2 (const svalue2 *arg)
-  : svalue2 (complexity (arg), arg->get_type ()), m_arg (arg)
+  unmergeable_svalue (const svalue *arg)
+  : svalue (complexity (arg), arg->get_type ()), m_arg (arg)
   {
   }
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_UNMERGEABLE; }
-  const unmergeable_svalue2 *
-  dyn_cast_unmergeable_svalue2 () const FINAL OVERRIDE { return this; }
+  const unmergeable_svalue *
+  dyn_cast_unmergeable_svalue () const FINAL OVERRIDE { return this; }
   void accept (visitor *v) const FINAL OVERRIDE;
-  bool implicitly_live_p (const svalue2_set &,
-			  const region_model2 *) const FINAL OVERRIDE;
+  bool implicitly_live_p (const svalue_set &,
+			  const region_model *) const FINAL OVERRIDE;
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const svalue2 *get_arg () const { return m_arg; }
+  const svalue *get_arg () const { return m_arg; }
 
  private:
-  const svalue2 *m_arg;
+  const svalue *m_arg;
 };
 
 } // namespace ana
@@ -969,23 +946,23 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const unmergeable_svalue2 *>::test (const svalue2 *sval)
+is_a_helper <const unmergeable_svalue *>::test (const svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_UNMERGEABLE;
+  return sval->get_kind () == svalue::SK_UNMERGEABLE;
 }
 
 namespace ana {
 
-/* Concrete subclass of svalue2 for use in selftests, where
-   we want a specific but unknown svalue2.
-   Unlike other svalue2 subclasses these aren't managed by
-   region_model2_manager.  */
+/* Concrete subclass of svalue for use in selftests, where
+   we want a specific but unknown svalue.
+   Unlike other svalue subclasses these aren't managed by
+   region_model_manager.  */
 
-class placeholder_svalue2 : public svalue2
+class placeholder_svalue : public svalue
 {
 public:
-  placeholder_svalue2 (tree type, const char *name)
-  : svalue2 (complexity (1, 1), type), m_name (name)
+  placeholder_svalue (tree type, const char *name)
+  : svalue (complexity (1, 1), type), m_name (name)
   {
   }
 
@@ -993,7 +970,7 @@ public:
   void accept (visitor *v) const FINAL OVERRIDE;
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
@@ -1001,7 +978,7 @@ public:
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
 #if 0
-  binop_svalue2 *dyn_cast_placeholder_svalue2 () FINAL OVERRIDE { return this; }
+  binop_svalue *dyn_cast_placeholder_svalue () FINAL OVERRIDE { return this; }
 #endif
 
  private:
@@ -1013,14 +990,14 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <placeholder_svalue2 *>::test (svalue2 *sval)
+is_a_helper <placeholder_svalue *>::test (svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_PLACEHOLDER;
+  return sval->get_kind () == svalue::SK_PLACEHOLDER;
 }
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing a "widening" seen when merging
+/* Concrete subclass of svalue representing a "widening" seen when merging
    states, widening from a base value to {base value, iter value} and thus
    representing a possible fixed point in an iteration from the base to
    +ve infinity, or -ve infinity, and thus useful for representing a value
@@ -1031,18 +1008,18 @@ namespace ana {
 
    FIXME: firm this up; clarify the above.  */
 
-class widening_svalue2 : public svalue2
+class widening_svalue : public svalue
 {
 public:
-  /* A support class for uniquifying instances of widening_svalue2.  */
+  /* A support class for uniquifying instances of widening_svalue.  */
   struct key_t
   {
 #if 0
     struct hash_map_traits
     {
       typedef key_t key_type;
-      typedef const widening_svalue2 *value_type;
-      typedef const widening_svalue2 *compare_type;
+      typedef const widening_svalue *value_type;
+      typedef const widening_svalue *compare_type;
 
       static inline hashval_t hash (const key_type &k)
       {
@@ -1050,17 +1027,17 @@ public:
 	gcc_assert (k != reinterpret_cast<key_type> (1));
 	return k->hash ();
       }
-      static inline bool equal_keys (const key_type &k1, const key_type &k2)
+      static inline bool equal_keys (const key_type &k1, const key_type &k)
       {
 	gcc_assert (k1 != NULL);
-	gcc_assert (k2 != NULL);
+	gcc_assert (k != NULL);
 	gcc_assert (k1 != reinterpret_cast<key_type> (1));
-	gcc_assert (k2 != reinterpret_cast<key_type> (1));
-	if (k1 && k2)
-	  return *k1 == *k2;
+	gcc_assert (k != reinterpret_cast<key_type> (1));
+	if (k1 && k)
+	  return *k1 == *k;
 	else
 	  /* Otherwise they must both be non-NULL.  */
-	  return k1 == k2;
+	  return k1 == k;
       }
       template <typename T>
       static inline void remove (T &)
@@ -1091,7 +1068,7 @@ public:
     };
 #endif
     key_t (tree type, const program_point &point,
-	   const svalue2 *base_sval, const svalue2 *iter_sval)
+	   const svalue *base_sval, const svalue *iter_sval)
       : m_type (type), m_point (point.get_function_point ()),
 	m_base_sval (base_sval), m_iter_sval (iter_sval)
     {}
@@ -1124,8 +1101,8 @@ public:
     // FIXME: for now, just the function_point, as it's easier to hash this
     function_point m_point;
 #endif
-    const svalue2 *m_base_sval;
-    const svalue2 *m_iter_sval;
+    const svalue *m_base_sval;
+    const svalue *m_iter_sval;
   };
 
   enum direction_t
@@ -1134,9 +1111,9 @@ public:
      DIR_DESCENDING,
      DIR_UNKNOWN
     };
-  widening_svalue2 (tree type, const program_point &point,
-		    const svalue2 *base_sval, const svalue2 *iter_sval)
-  : svalue2 (complexity::from_pair (base_sval->get_complexity (),
+  widening_svalue (tree type, const program_point &point,
+		    const svalue *base_sval, const svalue *iter_sval)
+  : svalue (complexity::from_pair (base_sval->get_complexity (),
 				    iter_sval->get_complexity ()),
 	     type),
     m_point (point.get_function_point ()),
@@ -1145,19 +1122,19 @@ public:
   }
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_WIDENING; }
-  const widening_svalue2 *dyn_cast_widening_svalue2 () const { return this; }
+  const widening_svalue *dyn_cast_widening_svalue () const { return this; }
   void accept (visitor *v) const FINAL OVERRIDE;
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const svalue2 *get_base_svalue2 () const { return m_base_sval; }
-  const svalue2 *get_iter_svalue2 () const { return m_iter_sval; }
+  const svalue *get_base_svalue () const { return m_base_sval; }
+  const svalue *get_iter_svalue () const { return m_iter_sval; }
 
   enum direction_t get_direction () const;
 
@@ -1170,8 +1147,8 @@ public:
 #else
   function_point m_point;
 #endif
-  const svalue2 *m_base_sval;
-  const svalue2 *m_iter_sval;
+  const svalue *m_base_sval;
+  const svalue *m_iter_sval;
 };
 
 } // namespace ana
@@ -1179,14 +1156,14 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <widening_svalue2 *>::test (svalue2 *sval)
+is_a_helper <widening_svalue *>::test (svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_WIDENING;
+  return sval->get_kind () == svalue::SK_WIDENING;
 }
 
 #if 1
-template <> struct default_hash_traits<widening_svalue2::key_t>
-: public member_function_hash_traits<widening_svalue2::key_t>
+template <> struct default_hash_traits<widening_svalue::key_t>
+: public member_function_hash_traits<widening_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
@@ -1194,23 +1171,23 @@ template <> struct default_hash_traits<widening_svalue2::key_t>
 
 namespace ana {
 
-/* Concrete subclass of svalue2 representing a mapping of bit-ranges
+/* Concrete subclass of svalue representing a mapping of bit-ranges
    to svalues, analogous to a cluster within the store.
 
    This is for use in places where we want to represent a store-like
-   mapping, but are required to use an svalue2, such as when handling
+   mapping, but are required to use an svalue, such as when handling
    compound assignments and compound return values.
 
    Instances of this class shouldn't be bound as-is into the store;
    instead they should be unpacked.  Similarly, they should not be
    nested.  */
 
-class compound_svalue2 : public svalue2
+class compound_svalue : public svalue
 {
 public:
   typedef binding_map::iterator_t iterator_t;
 
-  /* A support class for uniquifying instances of compound_svalue2.
+  /* A support class for uniquifying instances of compound_svalue.
      Note that to avoid copies, keys store pointers to binding_maps,
      rather than the maps themselves.  */
   struct key_t
@@ -1242,21 +1219,21 @@ public:
     const binding_map *m_map_ptr;
   };
 
-  compound_svalue2 (tree type, const binding_map &map)
-  : svalue2 (calc_complexity (map), type),
+  compound_svalue (tree type, const binding_map &map)
+  : svalue (calc_complexity (map), type),
     m_map (map)
   {
   }
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_COMPOUND; }
-  const compound_svalue2 *dyn_cast_compound_svalue2 () const { return this; }
+  const compound_svalue *dyn_cast_compound_svalue () const { return this; }
   void accept (visitor *v) const FINAL OVERRIDE;
 
   iterator_t begin () const { return m_map.begin (); }
   iterator_t end () const { return m_map.end (); }
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
@@ -1279,13 +1256,13 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <compound_svalue2 *>::test (svalue2 *sval)
+is_a_helper <compound_svalue *>::test (svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_COMPOUND;
+  return sval->get_kind () == svalue::SK_COMPOUND;
 }
 
-template <> struct default_hash_traits<compound_svalue2::key_t>
-: public member_function_hash_traits<compound_svalue2::key_t>
+template <> struct default_hash_traits<compound_svalue::key_t>
+: public member_function_hash_traits<compound_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
@@ -1296,7 +1273,7 @@ namespace ana {
    particular unknown value, rather than resorting to the unknown_value
    singleton, so that the value can have sm-state.
 
-   Comparisons of variables that share the same conjured_svalue2 are known
+   Comparisons of variables that share the same conjured_svalue are known
    to be equal, even if we don't know what the value is.
 
    For example, this is used for the values of regions that may have been
@@ -1309,15 +1286,15 @@ namespace ana {
    we want values to clobber a and b with, but we don't want to use the
    same value, or it would falsely implicitly assume that a == b.  */
 
-class conjured_svalue2 : public svalue2
+class conjured_svalue : public svalue
 {
 public:
   typedef binding_map::iterator_t iterator_t;
 
-  /* A support class for uniquifying instances of conjured_svalue2.  */
+  /* A support class for uniquifying instances of conjured_svalue.  */
   struct key_t
   {
-    key_t (tree type, const gimple *stmt, const region2 *id_reg)
+    key_t (tree type, const gimple *stmt, const region *id_reg)
     : m_type (type), m_stmt (stmt), m_id_reg (id_reg)
     {}
 
@@ -1349,22 +1326,22 @@ public:
 
     tree m_type;
     const gimple *m_stmt;
-    const region2 *m_id_reg;
+    const region *m_id_reg;
   };
 
-  conjured_svalue2 (tree type, const gimple *stmt, const region2 *id_reg)
-  : svalue2 (complexity (id_reg), type),
+  conjured_svalue (tree type, const gimple *stmt, const region *id_reg)
+  : svalue (complexity (id_reg), type),
     m_stmt (stmt), m_id_reg (id_reg)
   {
     gcc_assert (m_stmt != NULL);
   }
 
   enum kind get_kind () const FINAL OVERRIDE { return SK_CONJURED; }
-  const conjured_svalue2 *dyn_cast_conjured_svalue2 () const { return this; }
+  const conjured_svalue *dyn_cast_conjured_svalue () const { return this; }
   void accept (visitor *v) const FINAL OVERRIDE;
 
 #if 0
-  void dump_dot_to_pp (const region_model2 &model,
+  void dump_dot_to_pp (const region_model &model,
 		       pretty_printer *pp) const
     FINAL OVERRIDE;
 #endif
@@ -1373,7 +1350,7 @@ public:
 
  private:
   const gimple *m_stmt;
-  const region2 *m_id_reg;
+  const region *m_id_reg;
 };
 
 } // namespace ana
@@ -1381,14 +1358,14 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <conjured_svalue2 *>::test (svalue2 *sval)
+is_a_helper <conjured_svalue *>::test (svalue *sval)
 {
-  return sval->get_kind () == svalue2::SK_CONJURED;
+  return sval->get_kind () == svalue::SK_CONJURED;
 }
 
 #if 1
-template <> struct default_hash_traits<conjured_svalue2::key_t>
-: public member_function_hash_traits<conjured_svalue2::key_t>
+template <> struct default_hash_traits<conjured_svalue::key_t>
+: public member_function_hash_traits<conjured_svalue::key_t>
 {
   static const bool empty_zero_p = true;
 };
@@ -1414,15 +1391,15 @@ namespace ana {
        heap_region (RK_HEAP)
        root_region (RK_ROOT)
      function_region (RK_FUNCTION)
-     label_region2 (RK_LABEL)
+     label_region (RK_LABEL)
      symbolic_region (RK_SYMBOLIC)
-     field_region2 (RK_FIELD)
-     element_region2 (RK_ELEMENT)
-     offset_region2 (RK_OFFSET)
-     heap_allocated_region2 (RK_HEAP_ALLOCATED)
-     alloca_region2 (RK_ALLOCA)
-     string_region2 (RK_STRING)
-     unknown_region2 (RK_UNKNOWN).  */
+     field_region (RK_FIELD)
+     element_region (RK_ELEMENT)
+     offset_region (RK_OFFSET)
+     heap_allocated_region (RK_HEAP_ALLOCATED)
+     alloca_region (RK_ALLOCA)
+     string_region (RK_STRING)
+     unknown_region (RK_UNKNOWN).  */
 
 /* Abstract base class representing a chunk of memory.
 
@@ -1438,11 +1415,11 @@ namespace ana {
    has a "uninitialized" poison value which is inherited by all
    descendent regions that don't themselves have a value.  */
 
-class region2
+class region
 {
 public:
   /* An enum for discriminating between the different concrete subclasses
-     of region2.  */
+     of region.  */
   enum kind
   {
    RK_FRAME,
@@ -1466,69 +1443,57 @@ public:
   };
   static const char *kind_to_str (enum kind);
 
-  virtual ~region2 ();
+  virtual ~region ();
 
-  bool operator== (const region2 &other) const;
-  bool operator!= (const region2 &other) const { return !(*this == other); }
+  bool operator== (const region &other) const;
+  bool operator!= (const region &other) const { return !(*this == other); }
 
   unsigned get_id () const { return m_id; }
-  static int cmp_ids (const region2 *reg1, const region2 *reg2);
+  static int cmp_ids (const region *reg1, const region *reg2);
 
   virtual enum kind get_kind () const = 0;
-  virtual const frame_region2 *
-  dyn_cast_frame_region2 () const { return NULL; }
-  virtual const function_region2 *
-  dyn_cast_function_region2 () const { return NULL; }
-  virtual const symbolic_region2 *
-  dyn_cast_symbolic_region2 () const { return NULL; }
-  virtual const decl_region2 *
-  dyn_cast_decl_region2 () const { return NULL; }
-  virtual const field_region2 *
-  dyn_cast_field_region2 () const { return NULL; }
-  virtual const element_region2 *
-  dyn_cast_element_region2 () const { return NULL; }
-  virtual const offset_region2 *
-  dyn_cast_offset_region2 () const { return NULL; }
-  virtual const cast_region2 *
-  dyn_cast_cast_region2 () const { return NULL; }
-  virtual const string_region2 *
-  dyn_cast_string_region2 () const { return NULL; }
+  virtual const frame_region *
+  dyn_cast_frame_region () const { return NULL; }
+  virtual const function_region *
+  dyn_cast_function_region () const { return NULL; }
+  virtual const symbolic_region *
+  dyn_cast_symbolic_region () const { return NULL; }
+  virtual const decl_region *
+  dyn_cast_decl_region () const { return NULL; }
+  virtual const field_region *
+  dyn_cast_field_region () const { return NULL; }
+  virtual const element_region *
+  dyn_cast_element_region () const { return NULL; }
+  virtual const offset_region *
+  dyn_cast_offset_region () const { return NULL; }
+  virtual const cast_region *
+  dyn_cast_cast_region () const { return NULL; }
+  virtual const string_region *
+  dyn_cast_string_region () const { return NULL; }
 
   virtual void accept (visitor *v) const;
 
-  const region2 *get_parent_region () const { return m_parent; }
-  const region2 *get_base_region () const;
+  const region *get_parent_region () const { return m_parent; }
+  const region *get_base_region () const;
   bool base_region_p () const;
-  bool descendent_of_p (const region2 *elder) const;
-  const frame_region2 *maybe_get_frame_region () const;
+  bool descendent_of_p (const region *elder) const;
+  const frame_region *maybe_get_frame_region () const;
 
   tree maybe_get_decl () const;
 
-#if 0
-  void set_value (region_model2 &model, region_id this_rid, svalue2_id rhs_sid,
-		  region_model2_context *ctxt);
-  svalue2_id get_value (region_model2 &model, bool non_null,
-		       region_model2_context *ctxt);
-  svalue2_id get_value_direct () const { return m_sval_id; }
-
-  svalue2_id get_inherited_child_sid (region *child,
-				     region_model2 &model,
-				     region_model2_context *ctxt);
-#endif
-
   tree get_type () const { return m_type; }
 
   hashval_t hash () const;
 
-  void print (const region_model2 &model,
+  void print (const region_model &model,
 	      pretty_printer *pp) const;
   label_text get_desc (bool simple=true) const;
 
 #if 0
-  virtual void dump_dot_to_pp (const region_model2 &model,
+  virtual void dump_dot_to_pp (const region_model &model,
 			       pretty_printer *pp) const;
 #endif
-  void dump_to_pp (const region_model2 &model,
+  void dump_to_pp (const region_model &model,
 		   pretty_printer *pp,
 		   const char *prefix,
 		   bool is_last_child) const;
@@ -1537,16 +1502,10 @@ public:
   void dump (bool simple) const;
 
 #if 0
-  void add_view (region_id view_rid, region_model2 *model);
-  region_id get_view (tree type, region_model2 *model) const;
-  region_id get_active_view () const { return m_active_view_rid; }
-  bool is_view_p () const { return m_is_view; }
-#endif
-#if 0
-  virtual void validate (const region_model2 &model) const;
+  virtual void validate (const region_model &model) const;
 #endif
 
-  bool non_null_p (const region_model2 &model) const;
+  bool non_null_p (const region_model &model) const;
 
   static int cmp_ptrs (const void *, const void *);
 
@@ -1555,32 +1514,27 @@ public:
   bool get_bit_size (bit_size_t *out) const;
 
   void
-  get_subregions_for_binding (region_model2_manager *mgr,
+  get_subregions_for_binding (region_model_manager *mgr,
 			      bit_offset_t start_bit_offset,
 			      bit_size_t size_in_bits,
 			      tree type,
-			      auto_vec <const region2 *> *out) const;
+			      auto_vec <const region *> *out) const;
 
   bool symbolic_for_unknown_ptr_p () const;
 
   const complexity &get_complexity () const { return m_complexity; }
 
  protected:
-  region2 (complexity c, unsigned id, const region2 *parent, tree type);
+  region (complexity c, unsigned id, const region *parent, tree type);
 
   virtual void add_to_hash (inchash::hash &hstate) const;
 
  private:
-#if 0
-  void become_active_view (region_model2 &model, region_id this_rid);
-  void deactivate_any_active_view (region_model2 &model);
-  void deactivate_view (region_model2 &model, region_id this_view_rid);
-#endif
   region_offset calc_offset () const;
 
   complexity m_complexity;
   unsigned m_id; // purely for deterministic sorting at this stage, for dumps
-  const region2 *m_parent;
+  const region *m_parent;
   tree m_type;
 
   mutable region_offset *m_cached_offset;
@@ -1591,25 +1545,25 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const region2 *>::test (const region2 *)
+is_a_helper <const region *>::test (const region *)
 {
   return true;
 }
 
 namespace ana {
 
-/* Abstract subclass of region2, for regions that represent an untyped
+/* Abstract subclass of region, for regions that represent an untyped
    space within memory, such as the stack or the heap.  */
 
-class space_region2 : public region2
+class space_region : public region
 {
 protected:
-  space_region2 (unsigned id, const region2 *parent)
-  : region2 (complexity (parent), id, parent, NULL_TREE)
+  space_region (unsigned id, const region *parent)
+  : region (complexity (parent), id, parent, NULL_TREE)
   {}
 };
 
-/* Concrete space_region2 subclass, representing a function frame on the stack,
+/* Concrete space_region subclass, representing a function frame on the stack,
    to contain the locals.
    The parent is the stack region; there's also a hierarchy of call-stack
    prefixes expressed via m_calling_frame.
@@ -1621,20 +1575,20 @@ protected:
    where the parent region for each of the frames is the "stack" region.
    The index is the count of frames earlier than this in the stack.  */
 
-class frame_region2 : public space_region2
+class frame_region : public space_region
 {
 public:
-  frame_region2 (unsigned id, const region2 *parent,
-		 const frame_region2 *calling_frame,
+  frame_region (unsigned id, const region *parent,
+		 const frame_region *calling_frame,
 		 function *fun, int index)
-  : space_region2 (id, parent), m_calling_frame (calling_frame),
+  : space_region (id, parent), m_calling_frame (calling_frame),
     m_fun (fun), m_index (index)
   {}
-  ~frame_region2 ();
+  ~frame_region ();
 
-  /* region2 vfuncs.  */
+  /* region vfuncs.  */
   enum kind get_kind () const FINAL OVERRIDE { return RK_FRAME; }
-  const frame_region2 * dyn_cast_frame_region2 () const FINAL OVERRIDE
+  const frame_region * dyn_cast_frame_region () const FINAL OVERRIDE
   {
     return this;
   }
@@ -1645,23 +1599,23 @@ public:
 #endif
 
   /* Accessors.  */
-  const frame_region2 *get_calling_frame () const { return m_calling_frame; }
+  const frame_region *get_calling_frame () const { return m_calling_frame; }
   function *get_function () const { return m_fun; }
   int get_index () const { return m_index; }
   int get_stack_depth () const { return m_index + 1; }
 
-  bool compare_fields (const frame_region2 &other) const;
+  bool compare_fields (const frame_region &other) const;
 
-  const region2 *get_region_for_local (region_model2_manager *mgr,
+  const region *get_region_for_local (region_model_manager *mgr,
 				       tree expr) const;
 
   unsigned get_num_locals () const { return m_locals.elements (); }
 
  private:
-  const frame_region2 *m_calling_frame;
+  const frame_region *m_calling_frame;
   function *m_fun;
   int m_index;
-  typedef hash_map<tree, region2 *> map_t;
+  typedef hash_map<tree, region *> map_t;
   map_t m_locals;
   /* TODO: do we want a distinction between params (assumed initialized)
      vs temporaries?  */
@@ -1672,27 +1626,27 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const frame_region2 *>::test (const region2 *reg)
+is_a_helper <const frame_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_FRAME;
+  return reg->get_kind () == region::RK_FRAME;
 }
 
 namespace ana {
 
-/* Concrete space_region2 subclass, to hold global variables (data and bss).  */
+/* Concrete space_region subclass, to hold global variables (data and bss).  */
 
-class globals_region2 : public space_region2
+class globals_region : public space_region
 {
  public:
-  globals_region2 (unsigned id, const region2 *parent)
-  : space_region2 (id, parent)
+  globals_region (unsigned id, const region *parent)
+  : space_region (id, parent)
   {}
 
-  /* region2 vfuncs.  */
+  /* region vfuncs.  */
   enum kind get_kind () const FINAL OVERRIDE { return RK_GLOBALS; }
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  bool compare_fields (const globals_region2 &other) const;
+  bool compare_fields (const globals_region &other) const;
 };
 
 } // namespace ana
@@ -1700,32 +1654,32 @@ class globals_region2 : public space_region2
 template <>
 template <>
 inline bool
-is_a_helper <const globals_region2 *>::test (const region2 *reg)
+is_a_helper <const globals_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_GLOBALS;
+  return reg->get_kind () == region::RK_GLOBALS;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass.  A map_region2 representing the code, using
+/* Concrete region subclass.  A map_region representing the code, using
    FUNCTION_DECLs for its keys.  */
 
-class code_region2 : public space_region2
+class code_region : public space_region
 {
 public:
-  code_region2 (unsigned id, const region2 *parent)
-  : space_region2 (id, parent)
+  code_region (unsigned id, const region *parent)
+  : space_region (id, parent)
   {}
 
-  /* region2 vfuncs.  */
+  /* region vfuncs.  */
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
   enum kind get_kind () const FINAL OVERRIDE { return RK_CODE; }
 
-  const region2 *get_element (region_model2 *model,
-			const svalue2 *index,
-			region_model2_context *ctxt);
+  const region *get_element (region_model *model,
+			const svalue *index,
+			region_model_context *ctxt);
 
-  bool compare_fields (const code_region2 &other) const;
+  bool compare_fields (const code_region &other) const;
 };
 
 } // namespace ana
@@ -1733,40 +1687,40 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const code_region2 *>::test (const region2 *reg)
+is_a_helper <const code_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_CODE;
+  return reg->get_kind () == region::RK_CODE;
 }
 
 namespace ana {
 
 // FIXME:
-/* Concrete region2 subclass.  A region2 representing the code for
+/* Concrete region subclass.  A region representing the code for
    a particular function, using LABEL_DECLs for its keys.  */
 
-class function_region2 : public region2
+class function_region : public region
 {
 public:
-  function_region2 (unsigned id, const code_region2 *parent, tree fndecl)
-  : region2 (complexity (parent), id, parent, TREE_TYPE (fndecl)),
+  function_region (unsigned id, const code_region *parent, tree fndecl)
+  : region (complexity (parent), id, parent, TREE_TYPE (fndecl)),
     m_fndecl (fndecl)
   {
     gcc_assert (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (fndecl)));
   }
 
-  /* region2 vfuncs.  */
+  /* region vfuncs.  */
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
   enum kind get_kind () const FINAL OVERRIDE { return RK_FUNCTION; }
-  const function_region2 *
-  dyn_cast_function_region2 () const FINAL OVERRIDE{ return this; }
+  const function_region *
+  dyn_cast_function_region () const FINAL OVERRIDE{ return this; }
 
   tree get_fndecl () const { return m_fndecl; }
 
-  region2 *get_element (region_model2 *model,
-			const svalue2 *index_sid,
-			region_model2_context *ctxt);
+  region *get_element (region_model *model,
+			const svalue *index_sid,
+			region_model_context *ctxt);
 
-  bool compare_fields (const function_region2 &other) const;
+  bool compare_fields (const function_region &other) const;
 
 private:
   tree m_fndecl;
@@ -1777,30 +1731,30 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const function_region2 *>::test (const region2 *reg)
+is_a_helper <const function_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_FUNCTION;
+  return reg->get_kind () == region::RK_FUNCTION;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass.  A region2 representing a particular label
+/* Concrete region subclass.  A region representing a particular label
    within a function.  */
 
-class label_region2 : public region2
+class label_region : public region
 {
 public:
-  label_region2 (unsigned id, const function_region2 *parent, tree label)
-  : region2 (complexity (parent), id, parent, NULL_TREE), m_label (label)
+  label_region (unsigned id, const function_region *parent, tree label)
+  : region (complexity (parent), id, parent, NULL_TREE), m_label (label)
   {
     gcc_assert (TREE_CODE (label) == LABEL_DECL);
   }
 
-  /* region2 vfuncs.  */
+  /* region vfuncs.  */
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
   enum kind get_kind () const FINAL OVERRIDE { return RK_LABEL; }
 
-  //bool compare_fields (const function_region2 &other) const;
+  //bool compare_fields (const function_region &other) const;
 
 private:
   tree m_label;
@@ -1811,40 +1765,40 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const label_region2 *>::test (const region2 *reg)
+is_a_helper <const label_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_LABEL;
+  return reg->get_kind () == region::RK_LABEL;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass representing a stack, containing all stack
+/* Concrete region subclass representing a stack, containing all stack
    frames, and implicitly providing a POISON_KIND_UNINIT value to all
-   child region2s by default.  */
+   child regions by default.  */
 
-class stack_region2 : public region2
+class stack_region : public region
 {
 public:
-  stack_region2 (unsigned id, region2 *parent)
-  : region2 (complexity (parent), id, parent, NULL_TREE)
+  stack_region (unsigned id, region *parent)
+  : region (complexity (parent), id, parent, NULL_TREE)
   {}
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  bool compare_fields (const stack_region2 &other) const;
+  bool compare_fields (const stack_region &other) const;
 
   enum kind get_kind () const FINAL OVERRIDE { return RK_STACK; }
 
 #if 0
-  static bool can_merge_p (const stack_region2 *stack_region2_a,
-			   const stack_region2 *stack_region2_b,
+  static bool can_merge_p (const stack_region *stack_region_a,
+			   const stack_region *stack_region_b,
 			   model_merger *merger);
-  const svalue2 *get_value_by_name (tree identifier,
-			      const region_model2 &model) const;
+  const svalue *get_value_by_name (tree identifier,
+			      const region_model &model) const;
 #endif
 
 #if 0
-  void validate (const region_model2 &model) const FINAL OVERRIDE;
+  void validate (const region_model &model) const FINAL OVERRIDE;
 #endif
  private:
 #if 0
@@ -1857,35 +1811,29 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const stack_region2 *>::test (const region2 *reg)
+is_a_helper <const stack_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_STACK;
+  return reg->get_kind () == region::RK_STACK;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass: a region2 within which region2s can be
+/* Concrete region subclass: a region within which regions can be
    dynamically allocated.  */
 
-class heap_region2 : public region2
+class heap_region : public region
 {
 public:
-  heap_region2 (unsigned id, region2 *parent)
-  : region2 (complexity (parent), id, parent, NULL_TREE)
+  heap_region (unsigned id, region *parent)
+  : region (complexity (parent), id, parent, NULL_TREE)
   {}
 
 #if 0
-  bool compare_fields (const heap_region2 &other) const;
+  bool compare_fields (const heap_region &other) const;
 #endif
 
   enum kind get_kind () const FINAL OVERRIDE { return RK_HEAP; }
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
-#if 0
-  static bool can_merge_p (const heap_region2 *heap_a, region2_id heap_a_rid,
-			   const heap_region2 *heap_b, region2_id heap_b_rid,
-			   heap_region2 *merged_heap, region2_id merged_heap_rid,
-			   model_merger *merger);
-#endif
 };
 
 } // namespace ana
@@ -1893,39 +1841,39 @@ public:
 template <>
 template <>
 inline bool
-is_a_helper <const heap_region2 *>::test (const region2 *reg)
+is_a_helper <const heap_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_HEAP;
+  return reg->get_kind () == region::RK_HEAP;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass.  The root region2, containing all region2s
+/* Concrete region subclass.  The root region, containing all regions
    (either directly, or as descendents).
-   Unique within a region_model2.  */
+   Unique within a region_model.  */
 
-class root_region2 : public region2
+class root_region : public region
 {
 public:
-  root_region2 (unsigned id);
+  root_region (unsigned id);
 
-  bool compare_fields (const root_region2 &other) const;
+  bool compare_fields (const root_region &other) const;
 
   enum kind get_kind () const FINAL OVERRIDE { return RK_ROOT; }
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
 #if 0
-  static bool can_merge_p (const root_region2 *root_region2_a,
-			   const root_region2 *root_region2_b,
-			   root_region2 *merged_root_region2,
+  static bool can_merge_p (const root_region *root_region_a,
+			   const root_region *root_region_b,
+			   root_region *merged_root_region,
 			   model_merger *merger);
 #endif
 
-  const svalue2 *get_value_by_name (tree identifier,
-			      const region_model2 &model) const;
+  const svalue *get_value_by_name (tree identifier,
+			      const region_model &model) const;
 
 #if 0
-  void validate (const region_model2 &model) const FINAL OVERRIDE;
+  void validate (const region_model &model) const FINAL OVERRIDE;
 #endif
 
 private:
@@ -1939,38 +1887,38 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const root_region2 *>::test (const region2 *reg)
+is_a_helper <const root_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_ROOT;
+  return reg->get_kind () == region::RK_ROOT;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass: a region2 to use when dereferencing an unknown
+/* Concrete region subclass: a region to use when dereferencing an unknown
    pointer.  */
 
-class symbolic_region2 : public region2
+class symbolic_region : public region
 {
 public:
-  symbolic_region2 (unsigned id, region2 *parent, const svalue2 *sval_ptr)
-  : region2 (complexity::from_pair (parent, sval_ptr), id, parent,
+  symbolic_region (unsigned id, region *parent, const svalue *sval_ptr)
+  : region (complexity::from_pair (parent, sval_ptr), id, parent,
 	     TREE_TYPE (sval_ptr->get_type ())),
     m_sval_ptr (sval_ptr)
   {}
 
-  const symbolic_region2 *
-  dyn_cast_symbolic_region2 () const FINAL OVERRIDE { return this; }
+  const symbolic_region *
+  dyn_cast_symbolic_region () const FINAL OVERRIDE { return this; }
 
-  bool compare_fields (const symbolic_region2 &other) const;
+  bool compare_fields (const symbolic_region &other) const;
 
-  enum kind get_kind () const FINAL OVERRIDE { return region2::RK_SYMBOLIC; }
+  enum kind get_kind () const FINAL OVERRIDE { return region::RK_SYMBOLIC; }
   void accept (visitor *v) const FINAL OVERRIDE;
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const svalue2 *get_pointer () const { return m_sval_ptr; }
+  const svalue *get_pointer () const { return m_sval_ptr; }
 
 private:
-  const svalue2 *m_sval_ptr;
+  const svalue *m_sval_ptr;
 };
 
 } // namespace ana
@@ -1978,28 +1926,28 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const symbolic_region2 *>::test (const region2 *reg)
+is_a_helper <const symbolic_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_SYMBOLIC;
+  return reg->get_kind () == region::RK_SYMBOLIC;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass representing the memory occupied by a
+/* Concrete region subclass representing the memory occupied by a
    variable (whether for a global or a local).  */
 
-class decl_region2 : public region2
+class decl_region : public region
 {
 public:
-  decl_region2 (unsigned id, const region2 *parent, tree decl)
-  : region2 (complexity (parent), id, parent, TREE_TYPE (decl)), m_decl (decl)
+  decl_region (unsigned id, const region *parent, tree decl)
+  : region (complexity (parent), id, parent, TREE_TYPE (decl)), m_decl (decl)
   {}
 
-  bool compare_fields (const decl_region2 &other) const;
+  bool compare_fields (const decl_region &other) const;
 
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_DECL; }
-  const decl_region2 *
-  dyn_cast_decl_region2 () const FINAL OVERRIDE { return this; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_DECL; }
+  const decl_region *
+  dyn_cast_decl_region () const FINAL OVERRIDE { return this; }
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
@@ -2018,31 +1966,31 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const decl_region2 *>::test (const region2 *reg)
+is_a_helper <const decl_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_DECL;
+  return reg->get_kind () == region::RK_DECL;
 }
 
 namespace ana {
 
-/* Concrete region2 subclass representing the memory occupied by a
+/* Concrete region subclass representing the memory occupied by a
    field within a struct or union.  */
 
-class field_region2 : public region2
+class field_region : public region
 {
 public:
-  field_region2 (unsigned id, const region2 *parent, tree field)
-  : region2 (complexity (parent), id, parent, TREE_TYPE (field)),
+  field_region (unsigned id, const region *parent, tree field)
+  : region (complexity (parent), id, parent, TREE_TYPE (field)),
     m_field (field)
   {}
 
-  bool compare_fields (const field_region2 &other) const;
+  bool compare_fields (const field_region &other) const;
 
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_FIELD; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_FIELD; }
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
-  const field_region2 *
-  dyn_cast_field_region2 () const FINAL OVERRIDE { return this; }
+  const field_region *
+  dyn_cast_field_region () const FINAL OVERRIDE { return this; }
 
   tree get_field () const { return m_field; }
 
@@ -2058,41 +2006,41 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const field_region2 *>::test (const region2 *reg)
+is_a_helper <const field_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_FIELD;
+  return reg->get_kind () == region::RK_FIELD;
 }
 
 namespace ana {
 
 /* An element within an array.  */
 
-class element_region2 : public region2
+class element_region : public region
 {
 public:
-  element_region2 (unsigned id, const region2 *parent, tree element_type,
-		   const svalue2 *index)
-  : region2 (complexity::from_pair (parent, index), id, parent, element_type),
+  element_region (unsigned id, const region *parent, tree element_type,
+		   const svalue *index)
+  : region (complexity::from_pair (parent, index), id, parent, element_type),
     m_index (index)
   {}
 
-  bool compare_fields (const element_region2 &other) const;
+  bool compare_fields (const element_region &other) const;
 
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_ELEMENT; }
-  const element_region2 *
-  dyn_cast_element_region2 () const FINAL OVERRIDE { return this; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_ELEMENT; }
+  const element_region *
+  dyn_cast_element_region () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const svalue2 *get_index () const { return m_index; }
+  const svalue *get_index () const { return m_index; }
 
 protected:
   void add_to_hash (inchash::hash &hstate) const OVERRIDE;
 
 private:
-  const svalue2 *m_index;
+  const svalue *m_index;
 };
 
 } // namespace ana
@@ -2100,9 +2048,9 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const element_region2 *>::test (const region2 *reg)
+is_a_helper <const element_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_ELEMENT;
+  return reg->get_kind () == region::RK_ELEMENT;
 }
 
 namespace ana {
@@ -2110,32 +2058,32 @@ namespace ana {
 /* A byte-offset within another region, for handling pointer arithmetic
    as a region.  */
 
-class offset_region2 : public region2
+class offset_region : public region
 {
 public:
-  offset_region2 (unsigned id, const region2 *parent, tree type,
-		  const svalue2 *byte_offset)
-  : region2 (complexity::from_pair (parent, byte_offset), id, parent, type),
+  offset_region (unsigned id, const region *parent, tree type,
+		  const svalue *byte_offset)
+  : region (complexity::from_pair (parent, byte_offset), id, parent, type),
     m_byte_offset (byte_offset)
   {}
 
-  bool compare_fields (const offset_region2 &other) const;
+  bool compare_fields (const offset_region &other) const;
 
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_OFFSET; }
-  const offset_region2 *
-  dyn_cast_offset_region2 () const FINAL OVERRIDE { return this; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_OFFSET; }
+  const offset_region *
+  dyn_cast_offset_region () const FINAL OVERRIDE { return this; }
 
   void accept (visitor *v) const FINAL OVERRIDE;
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const svalue2 *get_byte_offset () const { return m_byte_offset; }
+  const svalue *get_byte_offset () const { return m_byte_offset; }
 
 protected:
   void add_to_hash (inchash::hash &hstate) const OVERRIDE;
 
 private:
-  const svalue2 *m_byte_offset;
+  const svalue *m_byte_offset;
 };
 
 } // namespace ana
@@ -2143,40 +2091,40 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const offset_region2 *>::test (const region2 *reg)
+is_a_helper <const offset_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_OFFSET;
+  return reg->get_kind () == region::RK_OFFSET;
 }
 
 namespace ana {
 
 /* A region that views another region using a different type.  */
 
-class cast_region2 : public region2
+class cast_region : public region
 {
 public:
-  cast_region2 (unsigned id, const region2 *original_region, tree type)
-  : region2 (complexity (original_region), id,
+  cast_region (unsigned id, const region *original_region, tree type)
+  : region (complexity (original_region), id,
 	     original_region->get_parent_region (), type),
     m_original_region (original_region)
   {}
 
-  bool compare_fields (const cast_region2 &other) const;
+  bool compare_fields (const cast_region &other) const;
 
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_CAST; }
-  const cast_region2 *
-  dyn_cast_cast_region2 () const FINAL OVERRIDE { return this; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_CAST; }
+  const cast_region *
+  dyn_cast_cast_region () const FINAL OVERRIDE { return this; }
   void accept (visitor *v) const FINAL OVERRIDE;
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
   /* FIXME: should this just be the parent region? */
-  const region2 *get_original_region () const { return m_original_region; }
+  const region *get_original_region () const { return m_original_region; }
 
 protected:
   void add_to_hash (inchash::hash &hstate) const OVERRIDE;
 
 private:
-  const region2 *m_original_region;
+  const region *m_original_region;
 };
 
 } // namespace ana
@@ -2184,9 +2132,9 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const cast_region2 *>::test (const region2 *reg)
+is_a_helper <const cast_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_CAST;
+  return reg->get_kind () == region::RK_CAST;
 }
 
 namespace ana {
@@ -2195,17 +2143,17 @@ namespace ana {
    or similar.  */
 // FIXME: ...but could be NULL
 
-class heap_allocated_region2 : public region2
+class heap_allocated_region : public region
 {
 public:
-  heap_allocated_region2 (unsigned id, const region2 *parent)
-  : region2 (complexity (parent), id, parent, NULL_TREE)
+  heap_allocated_region (unsigned id, const region *parent)
+  : region (complexity (parent), id, parent, NULL_TREE)
   {}
 
 #if 0
-  bool compare_fields (const element_region2 &other) const;
+  bool compare_fields (const element_region &other) const;
 #endif
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_HEAP_ALLOCATED; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_HEAP_ALLOCATED; }
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
@@ -2217,17 +2165,17 @@ protected:
 
 /* An untyped region dynamically allocated on the stack via "alloca".  */
 
-class alloca_region2 : public region2
+class alloca_region : public region
 {
 public:
-  alloca_region2 (unsigned id, const frame_region2 *parent)
-  : region2 (complexity (parent), id, parent, NULL_TREE)
+  alloca_region (unsigned id, const frame_region *parent)
+  : region (complexity (parent), id, parent, NULL_TREE)
   {}
 
 #if 0
-  bool compare_fields (const element_region2 &other) const;
+  bool compare_fields (const element_region &other) const;
 #endif
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_ALLOCA; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_ALLOCA; }
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
@@ -2239,21 +2187,21 @@ protected:
 
 /* A region for a STRING_CST.  */
 
-class string_region2 : public region2
+class string_region : public region
 {
 public:
-  string_region2 (unsigned id, const region2 *parent, tree string_cst)
-  : region2 (complexity (parent), id, parent, TREE_TYPE (string_cst)),
+  string_region (unsigned id, const region *parent, tree string_cst)
+  : region (complexity (parent), id, parent, TREE_TYPE (string_cst)),
     m_string_cst (string_cst)
   {}
 
-  const string_region2 *
-  dyn_cast_string_region2 () const FINAL OVERRIDE { return this; }
+  const string_region *
+  dyn_cast_string_region () const FINAL OVERRIDE { return this; }
 
 #if 0
-  bool compare_fields (const element_region2 &other) const;
+  bool compare_fields (const element_region &other) const;
 #endif
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_STRING; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_STRING; }
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
@@ -2272,26 +2220,26 @@ private:
 template <>
 template <>
 inline bool
-is_a_helper <const string_region2 *>::test (const region2 *reg)
+is_a_helper <const string_region *>::test (const region *reg)
 {
-  return reg->get_kind () == region2::RK_STRING;
+  return reg->get_kind () == region::RK_STRING;
 }
 
 namespace ana {
 
 /* An unknown region, for handling unimplemented tree codes.  */
 
-class unknown_region2 : public region2
+class unknown_region : public region
 {
 public:
-  unknown_region2 (unsigned id, const region2 *parent, tree type)
-  : region2 (complexity (parent), id, parent, type)
+  unknown_region (unsigned id, const region *parent, tree type)
+  : region (complexity (parent), id, parent, type)
   {}
 
 #if 0
-  bool compare_fields (const element_region2 &other) const;
+  bool compare_fields (const element_region &other) const;
 #endif
-  enum region2::kind get_kind () const FINAL OVERRIDE { return RK_UNKNOWN; }
+  enum region::kind get_kind () const FINAL OVERRIDE { return RK_UNKNOWN; }
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
@@ -2301,72 +2249,72 @@ protected:
 #endif
 };
 
-/* A class responsible for owning and consolidating region2 and svalue2
+/* A class responsible for owning and consolidating region and svalue
    instances.
-   region2 and svalue2 instances are immutable as far as clients are
+   region and svalue instances are immutable as far as clients are
    concerned, so they are provided as "const" ptrs.  */
 
-class region_model2_manager
+class region_model_manager
 {
 public:
-  region_model2_manager ();
-  ~region_model2_manager ();
+  region_model_manager ();
+  ~region_model_manager ();
 
-  /* svalue2 consolidation.  */
-  const svalue2 *get_or_create_constant_svalue2 (tree cst_expr);
-  const svalue2 *get_or_create_unknown_svalue2 (tree type);
-  const svalue2 *get_or_create_setjmp_svalue2 (const setjmp_record &r,
+  /* svalue consolidation.  */
+  const svalue *get_or_create_constant_svalue (tree cst_expr);
+  const svalue *get_or_create_unknown_svalue (tree type);
+  const svalue *get_or_create_setjmp_svalue (const setjmp_record &r,
 					       tree type);
-  const svalue2 *get_or_create_poisoned_svalue2 (enum poison_kind kind,
+  const svalue *get_or_create_poisoned_svalue (enum poison_kind kind,
 						 tree type);
-  const svalue2 *get_or_create_initial_value (const region2 *reg);
-  const svalue2 *get_ptr_svalue2 (tree ptr_type, const region2 *pointee);
-  const svalue2 *get_or_create_unaryop (tree type, enum tree_code op,
-					const svalue2 *arg);
-  const svalue2 *get_or_create_cast (tree type, const svalue2 *arg);
-  const svalue2 *get_or_create_binop (tree type,
+  const svalue *get_or_create_initial_value (const region *reg);
+  const svalue *get_ptr_svalue (tree ptr_type, const region *pointee);
+  const svalue *get_or_create_unaryop (tree type, enum tree_code op,
+					const svalue *arg);
+  const svalue *get_or_create_cast (tree type, const svalue *arg);
+  const svalue *get_or_create_binop (tree type,
 				      enum tree_code op,
-				      const svalue2 *arg0, const svalue2 *arg1);
-  const svalue2 *get_or_create_sub_svalue2 (tree type,
-					    const svalue2 *parent_svalue,
-					    const region2 *subregion);
-  const svalue2 *get_or_create_unmergeable (const svalue2 *arg);
-  const svalue2 *get_or_create_widening_svalue2 (tree type,
+				      const svalue *arg0, const svalue *arg1);
+  const svalue *get_or_create_sub_svalue (tree type,
+					    const svalue *parent_svalue,
+					    const region *subregion);
+  const svalue *get_or_create_unmergeable (const svalue *arg);
+  const svalue *get_or_create_widening_svalue (tree type,
 						 const program_point &point,
-						 const svalue2 *base_svalue,
-						 const svalue2 *iter_svalue);
-  const svalue2 *get_or_create_compound_svalue2 (tree type,
+						 const svalue *base_svalue,
+						 const svalue *iter_svalue);
+  const svalue *get_or_create_compound_svalue (tree type,
 						 const binding_map &map);
-  const svalue2 *get_or_create_conjured_svalue2 (tree type, const gimple *stmt,
-						 const region2 *id_reg);
-
-  /* region2 consolidation.  */
-  const stack_region2 * get_stack_region () const { return &m_stack_region; }
-  const heap_region2 *get_heap_region () const { return &m_heap_region; }
-  const code_region2 *get_code_region () const { return &m_code_region; }
-  const globals_region2 *get_globals_region () const
+  const svalue *get_or_create_conjured_svalue (tree type, const gimple *stmt,
+						 const region *id_reg);
+
+  /* region consolidation.  */
+  const stack_region * get_stack_region () const { return &m_stack_region; }
+  const heap_region *get_heap_region () const { return &m_heap_region; }
+  const code_region *get_code_region () const { return &m_code_region; }
+  const globals_region *get_globals_region () const
   {
     return &m_globals_region;
   }
-  const function_region2 *get_region_for_fndecl (tree fndecl);
-  const label_region2 *get_region_for_label (tree label);
-  const decl_region2 *get_region_for_global (tree expr);
-  const region2 *get_field_region (const region2 *parent, tree field);
-  const region2 *get_element_region (const region2 *parent,
+  const function_region *get_region_for_fndecl (tree fndecl);
+  const label_region *get_region_for_label (tree label);
+  const decl_region *get_region_for_global (tree expr);
+  const region *get_field_region (const region *parent, tree field);
+  const region *get_element_region (const region *parent,
 				     tree element_type,
-				     const svalue2 *index);
-  const region2 *get_offset_region (const region2 *parent,
+				     const svalue *index);
+  const region *get_offset_region (const region *parent,
 				    tree type,
-				    const svalue2 *byte_offset);
-  const region2 *get_cast_region (const region2 *original_region,
+				    const svalue *byte_offset);
+  const region *get_cast_region (const region *original_region,
 				  tree type);
-  const frame_region2 *get_frame_region (const frame_region2 *calling_frame,
+  const frame_region *get_frame_region (const frame_region *calling_frame,
 					 function *fun);
-  const region2 *get_symbolic_region (const svalue2 *sval);
-  const string_region2 *get_region_for_string (tree string_cst);
+  const region *get_symbolic_region (const svalue *sval);
+  const string_region *get_region_for_string (tree string_cst);
 
-  const region2 *
-  get_region2_for_unexpected_tree_code (region_model2_context *ctxt,
+  const region *
+  get_region_for_unexpected_tree_code (region_model_context *ctxt,
 					tree t,
 					const dump_location_t &loc);
 
@@ -2374,176 +2322,176 @@ public:
 
   store_manager *get_store_manager () { return &m_store_mgr; }
 
-  /* Dynamically-allocated region2 instances.
+  /* Dynamically-allocated region instances.
      FIXME: for now, the number of these within the analysis can grow
      arbitrarily.  They are still owned by the manager.  */
-  const region2 *create_region_for_heap_alloc ();
-  const region2 *create_region_for_alloca (const frame_region2 *frame);
+  const region *create_region_for_heap_alloc ();
+  const region *create_region_for_alloca (const frame_region *frame);
 
   void log_stats (logger *logger, bool show_objs) const;
 
 private:
   bool too_complex_p (const complexity &c) const;
-  bool reject_if_too_complex (svalue2 *sval);
+  bool reject_if_too_complex (svalue *sval);
 
-  const svalue2 *maybe_fold_unaryop (tree type, enum tree_code op,
-				     const svalue2 *arg);
-  const svalue2 *maybe_fold_binop (tree type, enum tree_code op,
-				   const svalue2 *arg0, const svalue2 *arg1);
-  const svalue2 *maybe_fold_sub_svalue2 (tree type,
-					 const svalue2 *parent_svalue,
-					 const region2 *subregion);
+  const svalue *maybe_fold_unaryop (tree type, enum tree_code op,
+				     const svalue *arg);
+  const svalue *maybe_fold_binop (tree type, enum tree_code op,
+				   const svalue *arg0, const svalue *arg1);
+  const svalue *maybe_fold_sub_svalue (tree type,
+					 const svalue *parent_svalue,
+					 const region *subregion);
 
   unsigned m_next_region_id;
-  root_region2 m_root_region;
-  stack_region2 m_stack_region;
-  heap_region2 m_heap_region;
+  root_region m_root_region;
+  stack_region m_stack_region;
+  heap_region m_heap_region;
 
-  /* svalue2 consolidation.  */
-  typedef hash_map<tree, constant_svalue2 *> constants_map_t;
+  /* svalue consolidation.  */
+  typedef hash_map<tree, constant_svalue *> constants_map_t;
   constants_map_t m_constants_map;
 
-  typedef hash_map<tree, unknown_svalue2 *> unknowns_map_t;
+  typedef hash_map<tree, unknown_svalue *> unknowns_map_t;
   unknowns_map_t m_unknowns_map;
-  const unknown_svalue2 *m_unknown_NULL;
+  const unknown_svalue *m_unknown_NULL;
 
-  typedef hash_map<poisoned_svalue2::key_t,
-		   poisoned_svalue2 *> poisoned_values_map_t;
+  typedef hash_map<poisoned_svalue::key_t,
+		   poisoned_svalue *> poisoned_values_map_t;
   poisoned_values_map_t m_poisoned_values_map;
 
-  typedef hash_map<setjmp_svalue2::key_t,
-		   setjmp_svalue2 *> setjmp_values_map_t;
+  typedef hash_map<setjmp_svalue::key_t,
+		   setjmp_svalue *> setjmp_values_map_t;
   setjmp_values_map_t m_setjmp_values_map;
 
-  typedef hash_map<const region2 *, initial_svalue2 *> initial_values_map_t;
+  typedef hash_map<const region *, initial_svalue *> initial_values_map_t;
   initial_values_map_t m_initial_values_map;
 
-  typedef hash_map<const region2 *, region_svalue2 *> pointer_values_map_t;
+  typedef hash_map<const region *, region_svalue *> pointer_values_map_t;
   pointer_values_map_t m_pointer_values_map;
 
-  typedef hash_map<unaryop_svalue2::key_t,
-		   unaryop_svalue2 *> unaryop_values_map_t;
+  typedef hash_map<unaryop_svalue::key_t,
+		   unaryop_svalue *> unaryop_values_map_t;
   unaryop_values_map_t m_unaryop_values_map;
 
-  typedef hash_map<binop_svalue2::key_t, binop_svalue2 *> binop_values_map_t;
+  typedef hash_map<binop_svalue::key_t, binop_svalue *> binop_values_map_t;
   binop_values_map_t m_binop_values_map;
 
-  typedef hash_map<sub_svalue2::key_t, sub_svalue2 *> sub_values_map_t;
+  typedef hash_map<sub_svalue::key_t, sub_svalue *> sub_values_map_t;
   sub_values_map_t m_sub_values_map;
 
-  typedef hash_map<const svalue2 *,
-		   unmergeable_svalue2 *> unmergeable_values_map_t;
+  typedef hash_map<const svalue *,
+		   unmergeable_svalue *> unmergeable_values_map_t;
   unmergeable_values_map_t m_unmergeable_values_map;
 
-  typedef hash_map<widening_svalue2::key_t,
-		   widening_svalue2 */*,
-	           widening_svalue2::key_t::hash_map_traits*/>
+  typedef hash_map<widening_svalue::key_t,
+		   widening_svalue */*,
+		   widening_svalue::key_t::hash_map_traits*/>
     widening_values_map_t;
   widening_values_map_t m_widening_values_map;
 
-  typedef hash_map<compound_svalue2::key_t,
-		   compound_svalue2 *> compound_values_map_t;
+  typedef hash_map<compound_svalue::key_t,
+		   compound_svalue *> compound_values_map_t;
   compound_values_map_t m_compound_values_map;
 
-  typedef hash_map<conjured_svalue2::key_t,
-		   conjured_svalue2 *> conjured_values_map_t;
+  typedef hash_map<conjured_svalue::key_t,
+		   conjured_svalue *> conjured_values_map_t;
   conjured_values_map_t m_conjured_values_map;
 
   /* Maximum complexity of svalues that weren't rejected.  */
   complexity m_max_complexity;
 
-  /* region2 consolidation.  */
+  /* region consolidation.  */
 
-  code_region2 m_code_region;
-  typedef hash_map<tree, function_region2 *> fndecls_map_t;
+  code_region m_code_region;
+  typedef hash_map<tree, function_region *> fndecls_map_t;
   typedef fndecls_map_t::iterator fndecls_iterator_t;
   fndecls_map_t m_fndecls_map;
 
-  typedef hash_map<tree, label_region2 *> labels_map_t;
+  typedef hash_map<tree, label_region *> labels_map_t;
   typedef labels_map_t::iterator labels_iterator_t;
   labels_map_t m_labels_map;
 
-  globals_region2 m_globals_region;
-  typedef hash_map<tree, decl_region2 *> globals_map_t;
+  globals_region m_globals_region;
+  typedef hash_map<tree, decl_region *> globals_map_t;
   typedef globals_map_t::iterator globals_iterator_t;
   globals_map_t m_globals_map;
 
-  uniq_manager<region2> m_fields;
+  uniq_manager<region> m_fields;
 #if 0
-  struct field_key_t { region2 *m_parent; tree m_field; };
-  typedef hash_map<field_key_t, region2 *> fields_map_t;
+  struct field_key_t { region *m_parent; tree m_field; };
+  typedef hash_map<field_key_t, region *> fields_map_t;
   fields_map_t m_fields_map;
 #endif
-  uniq_manager<region2> m_elements;
-  uniq_manager<region2> m_offset_regions;
-  uniq_manager<region2> m_cast_regions;
-  uniq_manager<frame_region2> m_frames;
-  uniq_manager<region2> m_symbolic_regions;
+  uniq_manager<region> m_elements;
+  uniq_manager<region> m_offset_regions;
+  uniq_manager<region> m_cast_regions;
+  uniq_manager<frame_region> m_frames;
+  uniq_manager<region> m_symbolic_regions;
 
-  typedef hash_map<tree, string_region2 *> string_map_t;
+  typedef hash_map<tree, string_region *> string_map_t;
   string_map_t m_string_map;
 
   store_manager m_store_mgr;
 
-  /* "Dynamically-allocated" region2 instances.
+  /* "Dynamically-allocated" region instances.
      FIXME: for now, the number of these within the analysis can grow
      arbitrarily.  They are still owned by the manager.  */
-  auto_delete_vec<region2> m_managed_dynamic_regions;
+  auto_delete_vec<region> m_managed_dynamic_regions;
 };
 
 struct append_ssa_names_cb_data;
 
 /* Helper class for handling calls to functions with known behavior.
-   Implemented in region-model2-impl-calls.c.  */
+   Implemented in region-model-impl-calls.c.  */
 
 class call_details
 {
 public:
-  call_details (const gcall *call, region_model2 *model,
-		region_model2_context *ctxt);
+  call_details (const gcall *call, region_model *model,
+		region_model_context *ctxt);
 
-  region_model2_context *get_ctxt () const { return m_ctxt; }
+  region_model_context *get_ctxt () const { return m_ctxt; }
   tree get_lhs_type () const { return m_lhs_type; }
-  const region2 *get_lhs_region () const { return m_lhs_region; }
+  const region *get_lhs_region () const { return m_lhs_region; }
 
-  bool maybe_set_lhs (const svalue2 *result) const;
+  bool maybe_set_lhs (const svalue *result) const;
 
   tree get_arg_tree (unsigned idx) const;
-  const svalue2 *get_arg_svalue2 (unsigned idx) const;
+  const svalue *get_arg_svalue (unsigned idx) const;
 
   void dump_to_pp (pretty_printer *pp, bool simple) const;
   void dump (bool simple) const;
 
 private:
   const gcall *m_call;
-  region_model2 *m_model;
-  region_model2_context *m_ctxt;
+  region_model *m_model;
+  region_model_context *m_ctxt;
   tree m_lhs_type;
-  const region2 *m_lhs_region;
+  const region *m_lhs_region;
 };
 
-/* A region_model2 encapsulates a representation of the state of memory, with
-   a tree of region2s, along with their associated values.
+/* A region_model encapsulates a representation of the state of memory, with
+   a tree of regions, along with their associated values.
    The representation is graph-like because values can be pointers to
-   region2s.
+   regions.
    It also stores a constraint_manager, capturing relationships between
    the values.  */
 
-class region_model2
+class region_model
 {
  public:
-  region_model2 (region_model2_manager *mgr);
-  region_model2 (const region_model2 &other);
-  ~region_model2 ();
+  region_model (region_model_manager *mgr);
+  region_model (const region_model &other);
+  ~region_model ();
 
 #if 0//__cplusplus >= 201103
   region_model2 (region_model2 &&other);
 #endif
 
-  region_model2 &operator= (const region_model2 &other);
+  region_model &operator= (const region_model &other);
 
-  bool operator== (const region_model2 &other) const;
-  bool operator!= (const region_model2 &other) const
+  bool operator== (const region_model &other) const;
+  bool operator!= (const region_model &other) const
   {
     return !(*this == other);
   }
@@ -2567,26 +2515,26 @@ class region_model2
   void validate () const;
 
   bool on_stmt (const gimple *stmt,
-		region_model2_context *ctxt);
+		region_model_context *ctxt);
   bool on_gassign (const gassign *stmt,
-		   region_model2_context *ctxt);
-  const svalue2 * get_gassign_result (const gassign *assign,
-				      region_model2_context *ctxt);
+		   region_model_context *ctxt);
+  const svalue * get_gassign_result (const gassign *assign,
+				      region_model_context *ctxt);
 #if 0
   bool on_gcall (const supernode *snode,
 		 const gcall *stmt);
 #else
-  bool on_call_pre (const gcall *stmt, region_model2_context *ctxt);
+  bool on_call_pre (const gcall *stmt, region_model_context *ctxt);
   void on_call_post (const gcall *stmt,
 		     bool unknown_side_effects,
-		     region_model2_context *ctxt);
+		     region_model_context *ctxt);
 
   /* Specific handling for on_call_pre.  */
   bool impl_call_alloca (const call_details &cd);
   void impl_call_analyzer_describe (const gcall *call,
-				    region_model2_context *ctxt);
+				    region_model_context *ctxt);
   void impl_call_analyzer_eval (const gcall *call,
-				region_model2_context *ctxt);
+				region_model_context *ctxt);
   bool impl_call_builtin_expect (const call_details &cd);
   bool impl_call_calloc (const call_details &cd);
   void impl_call_free (const call_details &cd);
@@ -2595,215 +2543,163 @@ class region_model2
   bool impl_call_strlen (const call_details &cd);
 #endif
   void handle_unrecognized_call (const gcall *call,
-				 region_model2_context *ctxt);
-  void get_reachable_svalues (svalue2_set *out,
-			      const svalue2 *extra_sval);
+				 region_model_context *ctxt);
+  void get_reachable_svalues (svalue_set *out,
+			      const svalue *extra_sval);
   bool on_greturn (const greturn *stmt,
-		   region_model2_context *ctxt);
+		   region_model_context *ctxt);
   void on_setjmp (const gcall *stmt, const exploded_node *enode,
-		  region_model2_context *ctxt);
+		  region_model_context *ctxt);
   void on_longjmp (const gcall *longjmp_call, const gcall *setjmp_call,
-		   int setjmp_stack_depth, region_model2_context *ctxt);
+		   int setjmp_stack_depth, region_model_context *ctxt);
 
   void update_for_phis (const supernode *snode,
 			const cfg_superedge *last_cfg_superedge,
-			region_model2_context *ctxt);
+			region_model_context *ctxt);
 
   void handle_phi (const gphi *phi,
 		   tree lhs, tree rhs, bool is_back_edge,
-		   region_model2_context *ctxt);
+		   region_model_context *ctxt);
 
   bool maybe_update_for_edge (const superedge &edge,
 			      const gimple *last_stmt,
-			      region_model2_context *ctxt);
+			      region_model_context *ctxt);
 
-  const region2 *push_frame (function *fun, vec<const svalue2 *> *arg_sids,
-			     region_model2_context *ctxt);
-  const frame_region2 *get_current_frame () const { return m_current_frame; }
+  const region *push_frame (function *fun, vec<const svalue *> *arg_sids,
+			     region_model_context *ctxt);
+  const frame_region *get_current_frame () const { return m_current_frame; }
   function * get_current_function () const;
-  void pop_frame (const region2 *result_dst,
-		  bool purge, purge_stats2 *stats,
-		  const svalue2 **out_result,
-		  region_model2_context *ctxt);
+  void pop_frame (const region *result_dst,
+		  bool purge, purge_stats *stats,
+		  const svalue **out_result,
+		  region_model_context *ctxt);
   int get_stack_depth () const;
-  const frame_region2 *get_frame_at_index (int index) const;
-
-#if 0
-  void replace_svalue2 (svalue2_id sid, const svalue2 *new_sval);
-#endif
+  const frame_region *get_frame_at_index (int index) const;
 
-  const region2 *get_lvalue (path_var pv, region_model2_context *ctxt);
-  const region2 *get_lvalue (tree expr, region_model2_context *ctxt);
-  const svalue2 *get_rvalue (path_var pv, region_model2_context *ctxt);
-  const svalue2 *get_rvalue (tree expr, region_model2_context *ctxt);
+  const region *get_lvalue (path_var pv, region_model_context *ctxt);
+  const region *get_lvalue (tree expr, region_model_context *ctxt);
+  const svalue *get_rvalue (path_var pv, region_model_context *ctxt);
+  const svalue *get_rvalue (tree expr, region_model_context *ctxt);
 
+  const region *deref_rvalue (const svalue *ptr_sval, tree ptr_tree,
+			       region_model_context *ctxt);
 #if 0
-  svalue2_id maybe_cast (tree type, svalue2_id sid, region_model2_context *ctxt);
-  svalue2_id maybe_cast_1 (tree type, svalue2_id sid);
-
-  region2_id get_field_region2 (region2_id rid, tree field,
-			      region_model2_context *ctxt);
-#endif
-
-  const region2 *deref_rvalue (const svalue2 *ptr_sval, tree ptr_tree,
-			       region_model2_context *ctxt);
-#if 0
-  const region2 *deref_rvalue (tree ptr, region_model2_context *ctxt);
+  const region *deref_rvalue (tree ptr, region_model_context *ctxt);
 #endif
 
-  void set_value (const region2 *lhs_reg, const svalue2 *rhs_sval,
-		  region_model2_context *ctxt);
-  void set_value (tree lhs, tree rhs, region_model2_context *ctxt);
-  void clobber_region (const region2 *reg);
-  void purge_region (const region2 *reg);
-  void zero_fill_region (const region2 *reg);
-  void mark_region_as_unknown (const region2 *reg);
+  void set_value (const region *lhs_reg, const svalue *rhs_sval,
+		  region_model_context *ctxt);
+  void set_value (tree lhs, tree rhs, region_model_context *ctxt);
+  void clobber_region (const region *reg);
+  void purge_region (const region *reg);
+  void zero_fill_region (const region *reg);
+  void mark_region_as_unknown (const region *reg);
 
 #if 0
-  const svalue2 *set_to_new_unknown_value (const region2 *dst_reg, tree type,
-				     region_model2_context *ctxt);
+  const svalue *set_to_new_unknown_value (const region *dst_reg, tree type,
+				     region_model_context *ctxt);
 #endif
-  void copy_region (const region2 *dst_reg, const region2 *src_reg,
-		    region_model2_context *ctxt);
-  tristate eval_condition (const svalue2 *lhs,
+  void copy_region (const region *dst_reg, const region *src_reg,
+		    region_model_context *ctxt);
+  tristate eval_condition (const svalue *lhs,
 			   enum tree_code op,
-			   const svalue2 *rhs) const;
-  tristate eval_condition_without_cm (const svalue2 *lhs,
+			   const svalue *rhs) const;
+  tristate eval_condition_without_cm (const svalue *lhs,
 				      enum tree_code op,
-				      const svalue2 *rhs) const;
-  tristate compare_initial_and_pointer (const initial_svalue2 *init,
-					const region_svalue2 *ptr) const;
+				      const svalue *rhs) const;
+  tristate compare_initial_and_pointer (const initial_svalue *init,
+					const region_svalue *ptr) const;
   tristate eval_condition (tree lhs,
 			   enum tree_code op,
 			   tree rhs,
-			   region_model2_context *ctxt);
+			   region_model_context *ctxt);
   bool add_constraint (tree lhs, enum tree_code op, tree rhs,
-		       region_model2_context *ctxt);
-#if 0
-  region2_id add_new_malloc_region2 ();
-#endif
-  const region2 *create_region_for_heap_alloc (const svalue2 *size_in_bytes);
-  const region2 *create_region_for_alloca (const svalue2 *size_in_bytes);
+		       region_model_context *ctxt);
+  const region *create_region_for_heap_alloc (const svalue *size_in_bytes);
+  const region *create_region_for_alloca (const svalue *size_in_bytes);
 
-  tree get_representative_tree (const svalue2 *sval) const;
+  tree get_representative_tree (const svalue *sval) const;
 #if 0
-  void get_path_vars_for_svalue2 (const svalue2 *sval,
+  void get_path_vars_for_svalue (const svalue *sval,
 				  auto_vec<path_var> *out) const;
 #endif
   path_var
-  get_representative_path_var (const svalue2 *sval,
-			       hash_set <const svalue2 *> *visited) const;
+  get_representative_path_var (const svalue *sval,
+			       hash_set <const svalue *> *visited) const;
   path_var
-  get_representative_path_var (const region2 *reg,
-			       hash_set <const svalue2 *> *visited) const;
+  get_representative_path_var (const region *reg,
+			       hash_set <const svalue *> *visited) const;
 
-#if 0
-  void purge_unused_svalue2s (purge_stats *out,
-			     region_model2_context *ctxt,
-			     svalue2_id_set *known_used_sids = NULL);
-  void purge_region2s (const region2_id_set &set,
-		      purge_stats *stats,
-		      logger *logger);
-#endif
   /* For selftests.  */
-  constraint_manager2 *get_constraints2 ()
+  constraint_manager *get_constraints ()
   {
-    return m_constraints2;
+    return m_constraints;
   }
 
   store *get_store () { return &m_store; }
   const store *get_store () const { return &m_store; }
 
-  region_model2_manager *get_manager () const { return m_mgr; }
+  region_model_manager *get_manager () const { return m_mgr; }
 
-#if 0
-  void get_descendents (region2_id rid, region2_id_set *out,
-			region2_id exclude_rid) const;
-#endif
-
-  void unbind_region2_and_descendents (const region2 *reg,
+  void unbind_region_and_descendents (const region *reg,
 				       enum poison_kind pkind,
-				       purge_stats2 *stats,
+				       purge_stats *stats,
 				       logger *logger);
 
-  bool can_merge_with_p (const region_model2 &other_model,
+  bool can_merge_with_p (const region_model &other_model,
 			 const program_point &point,
-			 region_model2 *out_model) const;
-#if 0
-  svalue2_id get_value_by_name (const char *name) const;
-
-  svalue2_id convert_byte_offset_to_array_index (tree ptr_type,
-						svalue2_id offset_sid);
-
-  region2_id get_or_create_mem_ref (tree type,
-				   svalue2_id ptr_sid,
-				   svalue2_id offset_sid,
-				   region_model2_context *ctxt);
-  region2_id get_or_create_pointer_plus_expr (tree type,
-					     svalue2_id ptr_sid,
-					     svalue2_id offset_sid,
-					     region_model2_context *ctxt);
-  region2_id get_or_create_view (region2_id raw_rid, tree type,
-				region_model2_context *ctxt);
-#endif
+			 region_model *out_model) const;
+
   tree get_fndecl_for_call (const gcall *call,
-			    region_model2_context *ctxt);
+			    region_model_context *ctxt);
 
   void get_ssa_name_regions_for_current_frame
-    (auto_vec<const decl_region2 *> *out) const;
-  static void append_ssa_names_cb (const region2 *base_reg,
+    (auto_vec<const decl_region *> *out) const;
+  static void append_ssa_names_cb (const region *base_reg,
 				   struct append_ssa_names_cb_data *data);
 
-  const svalue2 *get_store_value (const region2 *reg) const;
+  const svalue *get_store_value (const region *reg) const;
 
-  bool region_exists_p (const region2 *reg) const;
+  bool region_exists_p (const region *reg) const;
 
   void canonicalize ();
   bool canonicalized_p () const;
 
-  void loop_replay_hack (const region_model2 *dst_state);
+  void loop_replay_hack (const region_model *dst_state);
 
 private:
-  const region2 *get_lvalue_1 (path_var pv,
-			       region_model2_context *ctxt);
-  const svalue2 *get_rvalue_1 (path_var pv,
-			       region_model2_context *ctxt);
+  const region *get_lvalue_1 (path_var pv,
+			       region_model_context *ctxt);
+  const svalue *get_rvalue_1 (path_var pv,
+			       region_model_context *ctxt);
 
-#if 0
-  void copy_struct_region2 (region2_id dst_rid, struct_region2 *dst_reg,
-			   struct_region2 *src_reg, region_model2_context *ctxt);
-  void copy_union_region2 (region2_id dst_rid, union_region2 *src_reg,
-			  region_model2_context *ctxt);
-  void copy_array_region2 (region2_id dst_rid, array_region2 *dst_reg,
-			  array_region2 *src_reg, region_model2_context *ctxt);
-#endif
   void add_any_constraints_from_ssa_def_stmt (tree lhs,
 					      enum tree_code op,
 					      tree rhs,
-					      region_model2_context *ctxt);
+					      region_model_context *ctxt);
   void add_any_constraints_from_gassign (enum tree_code op,
 					 tree rhs,
 					 const gassign *assign,
-					 region_model2_context *ctxt);
+					 region_model_context *ctxt);
   void add_any_constraints_from_gcall (enum tree_code op,
 				       tree rhs,
 				       const gcall *call,
-				       region_model2_context *ctxt);
+				       region_model_context *ctxt);
 
   void update_for_call_superedge (const call_superedge &call_edge,
-				  region_model2_context *ctxt);
+				  region_model_context *ctxt);
   void update_for_return_superedge (const return_superedge &return_edge,
-				    region_model2_context *ctxt);
+				    region_model_context *ctxt);
   void update_for_call_summary (const callgraph_superedge &cg_sedge,
-				region_model2_context *ctxt);
+				region_model_context *ctxt);
   bool apply_constraints_for_gcond (const cfg_superedge &edge,
 				    const gcond *cond_stmt,
-				    region_model2_context *ctxt);
+				    region_model_context *ctxt);
   bool apply_constraints_for_gswitch (const switch_cfg_superedge &edge,
 				      const gswitch *switch_stmt,
-				      region_model2_context *ctxt);
+				      region_model_context *ctxt);
 
-  int poison_any_pointers_to_descendents (const region2 *reg,
+  int poison_any_pointers_to_descendents (const region *reg,
 					  enum poison_kind pkind);
 
 #if 0
@@ -2811,44 +2707,34 @@ private:
 				      auto_vec<path_var> *rep_path_vars,
 				      bool *is_first);
 #endif
-  void on_top_level_param (tree param, region_model2_context *ctxt);
+  void on_top_level_param (tree param, region_model_context *ctxt);
 
-  void record_dynamic_extents (const region2 *reg,
-			       const svalue2 *size_in_bytes);
+  void record_dynamic_extents (const region *reg,
+			       const svalue *size_in_bytes);
 
   /* Storing this here to avoid passing it around everywhere.  */
-  region_model2_manager *const m_mgr;
+  region_model_manager *const m_mgr;
 
   store m_store;
 
-  constraint_manager2 *m_constraints2; // TODO: embed, rather than dynalloc?
+  constraint_manager *m_constraints; // TODO: embed, rather than dynalloc?
 
-  const frame_region2 *m_current_frame;
+  const frame_region *m_current_frame;
 };
 
-/* Some region_model2 activity could lead to warnings (e.g. attempts to use an
+/* Some region_model activity could lead to warnings (e.g. attempts to use an
    uninitialized value).  This abstract base class encapsulates an interface
-   for the region2 model to use when emitting such warnings.
-
-   It also provides an interface for being notified about svalue2_ids being
-   remapped, and being deleted.
+   for the region model to use when emitting such warnings.
 
    Having this as an abstract base class allows us to support the various
-   operations needed by program_state in the analyzer within region_model2,
+   operations needed by program_state in the analyzer within region_model,
    whilst keeping them somewhat modularized.  */
 
-class region_model2_context
+class region_model_context
 {
  public:
   virtual void warn (pending_diagnostic *d) = 0;
 
-#if 0
-  /* Return true if if's OK to purge SID when simplifying state.
-     Subclasses can return false for values that have sm state,
-     to avoid generating "leak" false positives.  */
-  virtual bool can_purge_p (svalue2_id sid) = 0;
-#endif
-
   // FIXME:
   /* Hook for clients to be notified when a range of SIDs have
      been purged, so that they can purge state relating to those
@@ -2859,35 +2745,19 @@ class region_model2_context
      has purged (potentially for use in selftests).
      MAP has already been applied to the IDs, but is provided in case
      the client needs to figure out the old IDs.  */
-  virtual void on_svalue2_leak (const svalue2 *sval) = 0;
+  virtual void on_svalue_leak (const svalue *sval) = 0;
 
   /* Hook for clients to be notified when the set of explicitly live
-     svalue2s changes, so that they can purge state relating to dead
+     svalues changes, so that they can purge state relating to dead
      svalues.  */
   virtual void
-  on_liveness_change (const svalue2_set &live_svalues,
-		      const region_model2 *model) = 0;
+  on_liveness_change (const svalue_set &live_svalues,
+		      const region_model *model) = 0;
 
   virtual logger *get_logger () = 0;
 
-#if 0
-  /* Hook for clients to be notified when CHILD_SID is created
-     from PARENT_SID, when "inheriting" a value for a region2 from a
-     parent region2.
-     This exists so that state machines that inherit state can
-     propagate the state from parent to child.  */
-  virtual void on_inherited_svalue2 (svalue2_id parent_sid,
-				    svalue2_id child_sid) = 0;
-
-  /* Hook for clients to be notified when DST_SID is created
-     (or reused) as a cast from SRC_SID.
-     This exists so that state machines can propagate the state
-     from SRC_SID to DST_SID.  */
-  virtual void on_cast (svalue2_id src_sid,
-			svalue2_id dst_sid) = 0;
-#endif
   /* Hook for clients to be notified when the condition
-     "LHS OP RHS" is added to the region2 model.
+     "LHS OP RHS" is added to the region model.
      This exists so that state machines can detect tests on edges,
      and use them to trigger sm-state transitions (e.g. transitions due
      to ptrs becoming known to be NULL or non-NULL, rather than just
@@ -2897,45 +2767,34 @@ class region_model2_context
   // FIXME:
   /* Hooks for clients to be notified when an unknown change happens
      to BASE_REG (in response to a call to an unknown function).  */
-  virtual void on_unknown_change (const svalue2 *sval, bool is_mutable) = 0;
+  virtual void on_unknown_change (const svalue *sval, bool is_mutable) = 0;
 
   /* Hooks for clients to be notified when a phi node is handled,
      where RHS is the pertinent argument.  */
   virtual void on_phi (const gphi *phi, tree rhs) = 0;
 
-  /* Hooks for clients to be notified when the region2 model doesn't
+  /* Hooks for clients to be notified when the region model doesn't
      know how to handle the tree code of T at LOC.  */
   virtual void on_unexpected_tree_code (tree t,
 					const dump_location_t &loc) = 0;
 };
 
-/* A "do nothing" subclass of region_model2_context.  */
+/* A "do nothing" subclass of region_model_context.  */
 
-class noop_region_model2_context : public region_model2_context
+class noop_region_model_context : public region_model_context
 {
 public:
   void warn (pending_diagnostic *) OVERRIDE {}
-  void on_svalue2_leak (const svalue2 *) OVERRIDE {}
-  void on_liveness_change (const svalue2_set &,
-			   const region_model2 *) OVERRIDE {}
+  void on_svalue_leak (const svalue *) OVERRIDE {}
+  void on_liveness_change (const svalue_set &,
+			   const region_model *) OVERRIDE {}
   logger *get_logger () OVERRIDE { return NULL; }
-#if 0
-  void on_inherited_svalue2 (svalue2_id parent_sid ATTRIBUTE_UNUSED,
-			    svalue2_id child_sid  ATTRIBUTE_UNUSED)
-    OVERRIDE
-  {
-  }
-  void on_cast (svalue2_id src_sid ATTRIBUTE_UNUSED,
-		svalue2_id dst_sid ATTRIBUTE_UNUSED) OVERRIDE
-  {
-  }
-#endif
   void on_condition (tree lhs ATTRIBUTE_UNUSED,
 		     enum tree_code op ATTRIBUTE_UNUSED,
 		     tree rhs ATTRIBUTE_UNUSED) OVERRIDE
   {
   }
-  void on_unknown_change (const svalue2 *sval ATTRIBUTE_UNUSED,
+  void on_unknown_change (const svalue *sval ATTRIBUTE_UNUSED,
 			  bool is_mutable ATTRIBUTE_UNUSED) OVERRIDE
   {
   }
@@ -2946,13 +2805,13 @@ public:
   void on_unexpected_tree_code (tree, const dump_location_t &) OVERRIDE {}
 };
 
-/* A subclass of region_model2_context for determining if operations fail
-   e.g. "can we generate a region2 for the lvalue of EXPR?".  */
+/* A subclass of region_model_context for determining if operations fail
+   e.g. "can we generate a region for the lvalue of EXPR?".  */
 
-class tentative_region_model2_context : public noop_region_model2_context
+class tentative_region_model_context : public noop_region_model_context
 {
 public:
-  tentative_region_model2_context () : m_num_unexpected_codes (0) {}
+  tentative_region_model_context () : m_num_unexpected_codes (0) {}
 
   void on_unexpected_tree_code (tree, const dump_location_t &)
     FINAL OVERRIDE
@@ -2966,15 +2825,15 @@ private:
   int m_num_unexpected_codes;
 };
 
-/* A bundle of data for use when attempting to merge two region_model2
+/* A bundle of data for use when attempting to merge two region_model
    instances to make a third.  */
 
-struct model2_merger
+struct model_merger
 {
-  model2_merger (const region_model2 *model_a,
-		 const region_model2 *model_b,
+  model_merger (const region_model *model_a,
+		 const region_model *model_b,
 		 const program_point &point,
-		 region_model2 *merged_model)
+		 region_model *merged_model)
   : m_model_a (model_a), m_model_b (model_b),
     m_point (point),
     m_merged_model (merged_model)
@@ -2986,66 +2845,40 @@ struct model2_merger
   void dump (bool simple) const;
 
 #if ITERATED_BINOPS
-  void add_iterating_widening_binop_thing (const binop_svalue2 *binop_sval);
+  void add_iterating_widening_binop_thing (const binop_svalue *binop_sval);
 #endif
-  region_model2_manager *get_manager () const
+  region_model_manager *get_manager () const
   {
     return m_model_a->get_manager ();
   }
 
-#if 0
-  template <typename Subclass>
-  Subclass *get_region2_a (region2_id rid_a) const
-  {
-    return m_model_a->get_region2 <Subclass> (rid_a);
-  }
-
-  template <typename Subclass>
-  Subclass *get_region2_b (region2_id rid_b) const
-  {
-    return m_model_b->get_region2 <Subclass> (rid_b);
-  }
-
-  bool can_merge_values_p (svalue2_id sid_a,
-			   svalue2_id sid_b,
-			   svalue2_id *merged_sid);
-
-  void record_region2s (region2_id a_rid,
-		       region2_id b_rid,
-		       region2_id merged_rid);
-
-  void record_svalue2s (svalue2_id a_sid,
-		       svalue2_id b_sid,
-		       svalue2_id merged_sid);
-#endif
-
-  const region_model2 *m_model_a;
-  const region_model2 *m_model_b;
+  const region_model *m_model_a;
+  const region_model *m_model_b;
   const program_point &m_point;
-  region_model2 *m_merged_model;
+  region_model *m_merged_model;
 #if ITERATED_BINOPS
   /* FIXME: comment for this.  */
-  auto_vec<const binop_svalue2 *> m_iterated_binops;
+  auto_vec<const binop_svalue *> m_iterated_binops;
 #endif
 };
 
 /* FIXME.  */
 
-class engine2
+class engine
 {
 public:
-  region_model2_manager *get_model_manager () { return &m_mgr; }
+  region_model_manager *get_model_manager () { return &m_mgr; }
 
   void log_stats (logger *logger) const;
 
 private:
-  region_model2_manager m_mgr;
+  region_model_manager m_mgr;
 
 };
 
 } // namespace ana
 
-extern void debug (const region_model2 &rmodel);
+extern void debug (const region_model &rmodel);
 
 namespace ana {
 
@@ -3055,10 +2888,10 @@ namespace selftest {
 
 using namespace ::selftest;
 
-/* An implementation of region_model2_context for use in selftests, which
+/* An implementation of region_model_context for use in selftests, which
    stores any pending_diagnostic instances passed to it.  */
 
-class test_region_model2_context : public noop_region_model2_context
+class test_region_model_context : public noop_region_model_context
 {
 public:
   void warn (pending_diagnostic *d) FINAL OVERRIDE
@@ -3098,42 +2931,42 @@ private:
     ASSERT_FALSE (sat);				\
   SELFTEST_END_STMT
 
-/* Implementation detail of the ASSERT_CONDITION_*2 macros.  */
+/* Implementation detail of the ASSERT_CONDITION_* macros.  */
 
-void assert_condition2 (const location &loc,
-			region_model2 &model,
-			const svalue2 *lhs, tree_code op, const svalue2 *rhs,
+void assert_condition (const location &loc,
+			region_model &model,
+			const svalue *lhs, tree_code op, const svalue *rhs,
 			tristate expected);
 
-void assert_condition2 (const location &loc,
-			region_model2 &model,
+void assert_condition (const location &loc,
+			region_model &model,
 			tree lhs, tree_code op, tree rhs,
 			tristate expected);
 
-/* Assert that REGION_MODEL2 evaluates the condition "LHS OP RHS"
+/* Assert that REGION_MODEL evaluates the condition "LHS OP RHS"
    as "true".  */
 
-#define ASSERT_CONDITION_TRUE2(REGION_MODEL2, LHS, OP, RHS)		\
+#define ASSERT_CONDITION_TRUE(REGION_MODEL, LHS, OP, RHS)		\
   SELFTEST_BEGIN_STMT							\
-  assert_condition2 (SELFTEST_LOCATION, REGION_MODEL2, LHS, OP, RHS,	\
+  assert_condition (SELFTEST_LOCATION, REGION_MODEL, LHS, OP, RHS,	\
 		     tristate (tristate::TS_TRUE));			\
   SELFTEST_END_STMT
 
-/* Assert that REGION_MODEL2 evaluates the condition "LHS OP RHS"
+/* Assert that REGION_MODEL evaluates the condition "LHS OP RHS"
    as "false".  */
 
-#define ASSERT_CONDITION_FALSE2(REGION_MODEL2, LHS, OP, RHS) \
+#define ASSERT_CONDITION_FALSE(REGION_MODEL, LHS, OP, RHS) \
   SELFTEST_BEGIN_STMT							\
-  assert_condition2 (SELFTEST_LOCATION, REGION_MODEL2, LHS, OP, RHS,	\
+  assert_condition (SELFTEST_LOCATION, REGION_MODEL, LHS, OP, RHS,	\
 		     tristate (tristate::TS_FALSE));			\
   SELFTEST_END_STMT
 
-/* Assert that REGION_MODEL2 evaluates the condition "LHS OP RHS"
+/* Assert that REGION_MODEL evaluates the condition "LHS OP RHS"
    as "unknown".  */
 
-#define ASSERT_CONDITION_UNKNOWN2(REGION_MODEL2, LHS, OP, RHS) \
+#define ASSERT_CONDITION_UNKNOWN(REGION_MODEL, LHS, OP, RHS) \
   SELFTEST_BEGIN_STMT							\
-  assert_condition2 (SELFTEST_LOCATION, REGION_MODEL2, LHS, OP, RHS,	\
+  assert_condition (SELFTEST_LOCATION, REGION_MODEL, LHS, OP, RHS,	\
 		     tristate (tristate::TS_UNKNOWN));			\
   SELFTEST_END_STMT
 
@@ -3143,4 +2976,4 @@ void assert_condition2 (const location &loc,
 
 } // namespace ana
 
-#endif /* GCC_ANALYZER_REGION_MODEL_2_H */
+#endif /* GCC_ANALYZER_REGION_MODEL_H */
diff --git a/gcc/analyzer/region-model2-impl-calls.cc b/gcc/analyzer/region-model2-impl-calls.cc
index 3ef3dd21152..c9f6033f785 100644
--- a/gcc/analyzer/region-model2-impl-calls.cc
+++ b/gcc/analyzer/region-model2-impl-calls.cc
@@ -62,8 +62,8 @@ namespace ana {
 
 /* call_details's ctor.  */
 
-call_details::call_details (const gcall *call, region_model2 *model,
-			    region_model2_context *ctxt)
+call_details::call_details (const gcall *call, region_model *model,
+			    region_model_context *ctxt)
 : m_call (call), m_model (model), m_ctxt (ctxt),
   m_lhs_type (NULL_TREE), m_lhs_region (NULL)
 {
@@ -80,7 +80,7 @@ call_details::call_details (const gcall *call, region_model2 *model,
    Otherwise do nothing and return false.  */
 
 bool
-call_details::maybe_set_lhs (const svalue2 *result) const
+call_details::maybe_set_lhs (const svalue *result) const
 {
   gcc_assert (result);
   if (m_lhs_region)
@@ -100,10 +100,10 @@ call_details::get_arg_tree (unsigned idx) const
   return gimple_call_arg (m_call, idx);
 }
 
-/* Get argument IDX at the callsite as an svalue2.  */
+/* Get argument IDX at the callsite as an svalue.  */
 
-const svalue2 *
-call_details::get_arg_svalue2 (unsigned idx) const
+const svalue *
+call_details::get_arg_svalue (unsigned idx) const
 {
   tree arg = get_arg_tree (idx);
   return m_model->get_rvalue (arg, m_ctxt);
@@ -125,7 +125,7 @@ call_details::dump_to_pp (pretty_printer *pp, bool simple) const
   pp_newline (pp);
   for (unsigned i = 0; i < gimple_call_num_args (m_call); i++)
     {
-      const svalue2 *arg_sval = get_arg_svalue2 (i);
+      const svalue *arg_sval = get_arg_svalue (i);
       pp_printf (pp, "arg %i: ", i);
       arg_sval->dump_to_pp (pp, simple);
       pp_newline (pp);
@@ -150,12 +150,12 @@ call_details::dump (bool simple) const
 /* Handle the on_call_pre part of "alloca".  */
 
 bool
-region_model2::impl_call_alloca (const call_details &cd)
+region_model::impl_call_alloca (const call_details &cd)
 {
-  const svalue2 *size_sval = cd.get_arg_svalue2 (0);
-  const region2 *new_reg = create_region_for_alloca (size_sval);
-  const svalue2 *ptr_sval
-    = m_mgr->get_ptr_svalue2 (cd.get_lhs_type (), new_reg);
+  const svalue *size_sval = cd.get_arg_svalue (0);
+  const region *new_reg = create_region_for_alloca (size_sval);
+  const svalue *ptr_sval
+    = m_mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
   cd.maybe_set_lhs (ptr_sval);
   return true;
 }
@@ -167,12 +167,12 @@ region_model2::impl_call_alloca (const call_details &cd)
    debugging, and may be of use in DejaGnu tests.  */
 
 void
-region_model2::impl_call_analyzer_describe (const gcall *call,
-					    region_model2_context *ctxt)
+region_model::impl_call_analyzer_describe (const gcall *call,
+					   region_model_context *ctxt)
 {
   tree t_verbosity = gimple_call_arg (call, 0);
   tree t_val = gimple_call_arg (call, 1);
-  const svalue2 *sval = get_rvalue (t_val, ctxt);
+  const svalue *sval = get_rvalue (t_val, ctxt);
   bool simple = zerop (t_verbosity);
   label_text desc = sval->get_desc (simple);
   warning_at (call->location, 0, "svalue: %qs", desc.m_buffer);
@@ -187,8 +187,8 @@ region_model2::impl_call_analyzer_describe (const gcall *call,
    and what's more interesting is usually the def stmt for that name.  */
 
 void
-region_model2::impl_call_analyzer_eval (const gcall *call,
-					region_model2_context *ctxt)
+region_model::impl_call_analyzer_eval (const gcall *call,
+				       region_model_context *ctxt)
 {
   tree t_arg = gimple_call_arg (call, 0);
   tristate t = eval_condition (t_arg, NE_EXPR, integer_zero_node, ctxt);
@@ -198,10 +198,10 @@ region_model2::impl_call_analyzer_eval (const gcall *call,
 /* Handle the on_call_pre part of "__builtin_expect" etc.  */
 
 bool
-region_model2::impl_call_builtin_expect (const call_details &cd)
+region_model::impl_call_builtin_expect (const call_details &cd)
 {
   /* __builtin_expect's return value is its initial argument.  */
-  const svalue2 *sval = cd.get_arg_svalue2 (0);
+  const svalue *sval = cd.get_arg_svalue (0);
   cd.maybe_set_lhs (sval);
   return false;
 }
@@ -209,20 +209,20 @@ region_model2::impl_call_builtin_expect (const call_details &cd)
 /* Handle the on_call_pre part of "calloc".  */
 
 bool
-region_model2::impl_call_calloc (const call_details &cd)
+region_model::impl_call_calloc (const call_details &cd)
 {
-  const svalue2 *nmemb_sval = cd.get_arg_svalue2 (0);
-  const svalue2 *size_sval = cd.get_arg_svalue2 (1);
+  const svalue *nmemb_sval = cd.get_arg_svalue (0);
+  const svalue *size_sval = cd.get_arg_svalue (1);
   /* FIXME: check for overflow here?  */
-  const svalue2 *prod_sval
+  const svalue *prod_sval
     = m_mgr->get_or_create_binop (size_type_node, MULT_EXPR,
 				  nmemb_sval, size_sval);
-  const region2 *new_reg = create_region_for_heap_alloc (prod_sval);
+  const region *new_reg = create_region_for_heap_alloc (prod_sval);
   zero_fill_region (new_reg);
   if (cd.get_lhs_type ())
     {
-      const svalue2 *ptr_sval
-	= m_mgr->get_ptr_svalue2 (cd.get_lhs_type (), new_reg);
+      const svalue *ptr_sval
+	= m_mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
       cd.maybe_set_lhs (ptr_sval);
     }
   else
@@ -234,31 +234,31 @@ region_model2::impl_call_calloc (const call_details &cd)
 
 /* Handle the on_call_post part of "free", after sm-handling.
 
-   If the ptr points to an underlying heap region2, delete the region2,
-   poisoning pointers to it and region2s within it.
+   If the ptr points to an underlying heap region, delete the region,
+   poisoning pointers to it and regions within it.
 
    We delay this until after sm-state has been updated so that the
    sm-handling can transition all of the various casts of the pointer
-   to a "freed" state *before* we delete the related region2 here.
+   to a "freed" state *before* we delete the related region here.
 
    This has to be done here so that the sm-handling can use the fact
-   that they point to the same region2 to establish that they are equal
-   (in region_model2::eval_condition_without_cm), and thus transition
-   all pointers to the region2 to the "freed" state together, regardless
+   that they point to the same region to establish that they are equal
+   (in region_model::eval_condition_without_cm), and thus transition
+   all pointers to the region to the "freed" state together, regardless
    of casts.  */
 
 void
-region_model2::impl_call_free (const call_details &cd)
+region_model::impl_call_free (const call_details &cd)
 {
-  const svalue2 *ptr_sval = cd.get_arg_svalue2 (0);
-  if (const region_svalue2 *ptr_to_region2_sval
-      = ptr_sval->dyn_cast_region_svalue2 ())
+  const svalue *ptr_sval = cd.get_arg_svalue (0);
+  if (const region_svalue *ptr_to_region_sval
+      = ptr_sval->dyn_cast_region_svalue ())
     {
-      /* If the ptr points to an underlying heap region2, delete it,
+      /* If the ptr points to an underlying heap region, delete it,
 	 poisoning pointers.  */
-      const region2 *freed_reg = ptr_to_region2_sval->get_pointee ();
-      purge_stats2 stats;
-      unbind_region2_and_descendents (freed_reg,
+      const region *freed_reg = ptr_to_region_sval->get_pointee ();
+      purge_stats stats;
+      unbind_region_and_descendents (freed_reg,
 				      POISON_KIND_FREED,
 				      &stats, cd.get_ctxt ()->get_logger ());
       // TODO: do anything with stats?
@@ -268,14 +268,14 @@ region_model2::impl_call_free (const call_details &cd)
 /* Handle the on_call_pre part of "malloc".  */
 
 bool
-region_model2::impl_call_malloc (const call_details &cd)
+region_model::impl_call_malloc (const call_details &cd)
 {
-  const svalue2 *size_sval = cd.get_arg_svalue2 (0);
-  const region2 *new_reg = create_region_for_heap_alloc (size_sval);
+  const svalue *size_sval = cd.get_arg_svalue (0);
+  const region *new_reg = create_region_for_heap_alloc (size_sval);
   if (cd.get_lhs_type ())
     {
-      const svalue2 *ptr_sval
-	= m_mgr->get_ptr_svalue2 (cd.get_lhs_type (), new_reg);
+      const svalue *ptr_sval
+	= m_mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
       cd.maybe_set_lhs (ptr_sval);
     }
   else
@@ -288,13 +288,13 @@ region_model2::impl_call_malloc (const call_details &cd)
 /* Handle the on_call_pre part of "memset" and "__builtin_memset".  */
 
 bool
-region_model2::impl_call_memset (const call_details &cd)
+region_model::impl_call_memset (const call_details &cd)
 {
-  const svalue2 *dest_sval = cd.get_arg_svalue2 (0);
-  const svalue2 *fill_value_sval = cd.get_arg_svalue2 (1);
-  const svalue2 *num_bytes_sval = cd.get_arg_svalue2 (2);
+  const svalue *dest_sval = cd.get_arg_svalue (0);
+  const svalue *fill_value_sval = cd.get_arg_svalue (1);
+  const svalue *num_bytes_sval = cd.get_arg_svalue (2);
 
-  const region2 *dest_reg = deref_rvalue (dest_sval, cd.get_arg_tree (0),
+  const region *dest_reg = deref_rvalue (dest_sval, cd.get_arg_tree (0),
 					  cd.get_ctxt ());
 
   if (tree num_bytes = num_bytes_sval->maybe_get_constant ())
@@ -333,13 +333,13 @@ region_model2::impl_call_memset (const call_details &cd)
    Return true if the LHS is updated.  */
 
 bool
-region_model2::impl_call_strlen (const call_details &cd)
+region_model::impl_call_strlen (const call_details &cd)
 {
-  region_model2_context *ctxt = cd.get_ctxt ();
-  const svalue2 *arg_sval = cd.get_arg_svalue2 (0);
-  const region2 *buf_reg = deref_rvalue (arg_sval, cd.get_arg_tree (0), ctxt);
-  if (const string_region2 *str_reg
-      = buf_reg->dyn_cast_string_region2 ())
+  region_model_context *ctxt = cd.get_ctxt ();
+  const svalue *arg_sval = cd.get_arg_svalue (0);
+  const region *buf_reg = deref_rvalue (arg_sval, cd.get_arg_tree (0), ctxt);
+  if (const string_region *str_reg
+      = buf_reg->dyn_cast_string_region ())
     {
       tree str_cst = str_reg->get_string_cst ();
       /* TREE_STRING_LENGTH is sizeof, not strlen.  */
@@ -348,8 +348,8 @@ region_model2::impl_call_strlen (const call_details &cd)
       if (cd.get_lhs_type ())
 	{
 	  tree t_cst = build_int_cst (cd.get_lhs_type (), strlen_cst);
-	  const svalue2 *result_sval
-	    = m_mgr->get_or_create_constant_svalue2 (t_cst);
+	  const svalue *result_sval
+	    = m_mgr->get_or_create_constant_svalue (t_cst);
 	  cd.maybe_set_lhs (result_sval);
 	  return true;
 	}
diff --git a/gcc/analyzer/region-model2-reachability.cc b/gcc/analyzer/region-model2-reachability.cc
index 95b644efc7f..ade393d813b 100644
--- a/gcc/analyzer/region-model2-reachability.cc
+++ b/gcc/analyzer/region-model2-reachability.cc
@@ -71,8 +71,8 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace ana {
 
-reachable_region2s::reachable_region2s (store *store,
-					region_model2_manager *mgr)
+reachable_regions::reachable_regions (store *store,
+				      region_model_manager *mgr)
 : m_store (store), m_mgr (mgr), m_reachable_regs (), m_mutable_regs ()
 {
 }
@@ -80,20 +80,20 @@ reachable_region2s::reachable_region2s (store *store,
 /* Callback called for each cluster when initializing this object.  */
 
 void
-reachable_region2s::init_cluster_cb (const region2 *base_reg,
-				     reachable_region2s *this_ptr)
+reachable_regions::init_cluster_cb (const region *base_reg,
+				    reachable_regions *this_ptr)
 {
   this_ptr->init_cluster (base_reg);
 }
 
 /* Called for each cluster when initializing this object.  */
 void
-reachable_region2s::init_cluster (const region2 *base_reg)
+reachable_regions::init_cluster (const region *base_reg)
 {
   /* Mark any globals as mutable (and traverse what they point to).  */
-  const region2 *parent = base_reg->get_parent_region ();
+  const region *parent = base_reg->get_parent_region ();
   gcc_assert (parent);
-  if (parent->get_kind () == region2::RK_GLOBALS)
+  if (parent->get_kind () == region::RK_GLOBALS)
     add (base_reg, true);
 
   /* Mark any clusters that already escaped in previous unknown calls
@@ -103,14 +103,14 @@ reachable_region2s::init_cluster (const region2 *base_reg)
 
   /* If BASE_REG is *INIT_VAL(REG) for some other REG, see if REG is
      unbound and untouched.  If so, then add BASE_REG as a root.  */
-  if (const symbolic_region2 *sym_reg = base_reg->dyn_cast_symbolic_region2 ())
+  if (const symbolic_region *sym_reg = base_reg->dyn_cast_symbolic_region ())
     {
-      const svalue2 *ptr = sym_reg->get_pointer ();
-      if (const initial_svalue2 *init_sval = ptr->dyn_cast_initial_svalue2 ())
+      const svalue *ptr = sym_reg->get_pointer ();
+      if (const initial_svalue *init_sval = ptr->dyn_cast_initial_svalue ())
 	{
-	  const region2 *init_sval_reg = init_sval->get_region ();
-	  const region2 *other_base_reg = init_sval_reg->get_base_region ();
-	  const binding_cluster2 *other_cluster
+	  const region *init_sval_reg = init_sval->get_region ();
+	  const region *other_base_reg = init_sval_reg->get_base_region ();
+	  const binding_cluster *other_cluster
 	    = m_store->get_cluster (other_base_reg);
 	  if (other_cluster == NULL
 	      || !other_cluster->touched_p ())
@@ -122,11 +122,11 @@ reachable_region2s::init_cluster (const region2 *base_reg)
   /* Lazily mark the cluster containing REG as being reachable, recursively
      adding clusters reachable from REG's cluster.  */
 void
-reachable_region2s::add (const region2 *reg, bool is_mutable)
+reachable_regions::add (const region *reg, bool is_mutable)
 {
   gcc_assert (reg);
 
-  const region2 *base_reg = const_cast <region2 *> (reg->get_base_region ());
+  const region *base_reg = const_cast <region *> (reg->get_base_region ());
   gcc_assert (base_reg);
 
   /* Bail out if this cluster is already in the sets at the IS_MUTABLE
@@ -144,15 +144,15 @@ reachable_region2s::add (const region2 *reg, bool is_mutable)
     }
 
   /* Add values within the cluster.  If any are pointers, add the pointee.  */
-  if (binding_cluster2 *bind_cluster = m_store->get_cluster (base_reg))
+  if (binding_cluster *bind_cluster = m_store->get_cluster (base_reg))
     bind_cluster->for_each_value (handle_sval_cb, this);
   else
     handle_sval (m_mgr->get_or_create_initial_value (base_reg));
 }
 
 void
-reachable_region2s::handle_sval_cb (const svalue2 *sval,
-				    reachable_region2s *this_ptr)
+reachable_regions::handle_sval_cb (const svalue *sval,
+				   reachable_regions *this_ptr)
 {
   this_ptr->handle_sval (sval);
 }
@@ -160,12 +160,12 @@ reachable_region2s::handle_sval_cb (const svalue2 *sval,
 /* Add SVAL.  If it is a pointer, add the pointed-to region.  */
 
 void
-reachable_region2s::handle_sval (const svalue2 *sval)
+reachable_regions::handle_sval (const svalue *sval)
 {
   m_reachable_svals.add (sval);
-  if (const region_svalue2 *ptr = sval->dyn_cast_region_svalue2 ())
+  if (const region_svalue *ptr = sval->dyn_cast_region_svalue ())
     {
-      const region2 *pointee = ptr->get_pointee ();
+      const region *pointee = ptr->get_pointee ();
       /* Use const-ness of pointer type to affect mutability.  */
       bool ptr_is_mutable = true;
       if (ptr->get_type ()
@@ -180,18 +180,18 @@ reachable_region2s::handle_sval (const svalue2 *sval)
 	}
       add (pointee, ptr_is_mutable);
     }
-  /* Treat all svalues within a compound_svalue2 as reachable.  */
-  if (const compound_svalue2 *compound_sval
-      = sval->dyn_cast_compound_svalue2 ())
+  /* Treat all svalues within a compound_svalue as reachable.  */
+  if (const compound_svalue *compound_sval
+      = sval->dyn_cast_compound_svalue ())
     {
-      for (compound_svalue2::iterator_t iter = compound_sval->begin ();
+      for (compound_svalue::iterator_t iter = compound_sval->begin ();
 	   iter != compound_sval->end (); ++iter)
 	{
-	  const svalue2 *iter_sval = (*iter).second;
+	  const svalue *iter_sval = (*iter).second;
 	  handle_sval (iter_sval);
 	}
     }
-  if (const svalue2 *cast = sval->maybe_undo_cast ())
+  if (const svalue *cast = sval->maybe_undo_cast ())
     handle_sval (cast);
 }
 
@@ -199,7 +199,7 @@ reachable_region2s::handle_sval (const svalue2 *sval)
    Use PARAM_TYPE for determining mutability.  */
 
 void
-reachable_region2s::handle_parm (const svalue2 *sval, tree param_type)
+reachable_regions::handle_parm (const svalue *sval, tree param_type)
 {
   bool is_mutable = true;
   if (param_type
@@ -210,10 +210,10 @@ reachable_region2s::handle_parm (const svalue2 *sval, tree param_type)
     m_mutable_svals.add (sval);
   else
     m_reachable_svals.add (sval);
-  if (const region_svalue2 *parm_ptr
-      = sval->dyn_cast_region_svalue2 ())
+  if (const region_svalue *parm_ptr
+      = sval->dyn_cast_region_svalue ())
     {
-      const region2 *pointee_reg = parm_ptr->get_pointee ();
+      const region *pointee_reg = parm_ptr->get_pointee ();
       add (pointee_reg, is_mutable);
     }
 }
@@ -222,12 +222,12 @@ reachable_region2s::handle_parm (const svalue2 *sval, tree param_type)
    as having escaped.  */
 
 void
-reachable_region2s::mark_escaped_clusters (store_manager *mgr)
+reachable_regions::mark_escaped_clusters (store_manager *mgr)
 {
-  for (hash_set<const region2 *>::iterator iter = m_mutable_regs.begin ();
+  for (hash_set<const region *>::iterator iter = m_mutable_regs.begin ();
        iter != m_mutable_regs.end (); ++iter)
     {
-      const region2 *base_reg = *iter;
+      const region *base_reg = *iter;
       m_store->mark_as_escaped (base_reg);
     }
 }
@@ -235,11 +235,11 @@ reachable_region2s::mark_escaped_clusters (store_manager *mgr)
 /* Dump a multiline representation of this object to PP.  */
 
 void
-reachable_region2s::dump_to_pp (pretty_printer *pp) const
+reachable_regions::dump_to_pp (pretty_printer *pp) const
 {
   pp_string (pp, "reachable clusters: ");
   pp_newline (pp);
-  for (hash_set<const region2 *>::iterator iter = m_reachable_regs.begin ();
+  for (hash_set<const region *>::iterator iter = m_reachable_regs.begin ();
        iter != m_reachable_regs.end (); ++iter)
     {
       pp_string (pp, "  ");
@@ -248,7 +248,7 @@ reachable_region2s::dump_to_pp (pretty_printer *pp) const
     }
   pp_string (pp, "mutable clusters: ");
   pp_newline (pp);
-  for (hash_set<const region2 *>::iterator iter = m_mutable_regs.begin ();
+  for (hash_set<const region *>::iterator iter = m_mutable_regs.begin ();
        iter != m_mutable_regs.end (); ++iter)
     {
       pp_string (pp, "  ");
@@ -257,7 +257,7 @@ reachable_region2s::dump_to_pp (pretty_printer *pp) const
     }
   pp_string (pp, "reachable svals: ");
   pp_newline (pp);
-  for (hash_set<const svalue2 *>::iterator iter = m_reachable_svals.begin ();
+  for (hash_set<const svalue *>::iterator iter = m_reachable_svals.begin ();
        iter != m_reachable_svals.end (); ++iter)
     {
       pp_string (pp, "  ");
@@ -266,7 +266,7 @@ reachable_region2s::dump_to_pp (pretty_printer *pp) const
     }
   pp_string (pp, "mutable svals: ");
   pp_newline (pp);
-  for (hash_set<const svalue2 *>::iterator iter = m_mutable_svals.begin ();
+  for (hash_set<const svalue *>::iterator iter = m_mutable_svals.begin ();
        iter != m_mutable_svals.end (); ++iter)
     {
       pp_string (pp, "  ");
@@ -278,7 +278,7 @@ reachable_region2s::dump_to_pp (pretty_printer *pp) const
 /* Dump a multiline representation of this object to stderr.  */
 
 DEBUG_FUNCTION void
-reachable_region2s::dump () const
+reachable_regions::dump () const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
diff --git a/gcc/analyzer/region-model2-reachability.h b/gcc/analyzer/region-model2-reachability.h
index 8c49b3f0090..6c3c0f316d7 100644
--- a/gcc/analyzer/region-model2-reachability.h
+++ b/gcc/analyzer/region-model2-reachability.h
@@ -18,69 +18,69 @@ 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_REGION_MODEL2_REACHABILITY_H
-#define GCC_ANALYZER_REGION_MODEL2_REACHABILITY_H
+#ifndef GCC_ANALYZER_REGION_MODEL_REACHABILITY_H
+#define GCC_ANALYZER_REGION_MODEL_REACHABILITY_H
 
 namespace ana {
 
-/* Helper class for region_model2::handle_unrecognized_call, for keeping
-   track of all region2s that are reachable, and, of those, which are
+/* Helper class for region_model::handle_unrecognized_call, for keeping
+   track of all regions that are reachable, and, of those, which are
    mutable.
    FIXME: also for detecting leaks.  */
 
-class reachable_region2s
+class reachable_regions
 {
 public:
-  reachable_region2s (store *store, region_model2_manager *mgr);
+  reachable_regions (store *store, region_model_manager *mgr);
 
   /* Callback called for each cluster when initializing this object.  */
-  static void init_cluster_cb (const region2 *base_reg,
-			       reachable_region2s *this_ptr);
+  static void init_cluster_cb (const region *base_reg,
+			       reachable_regions *this_ptr);
 
   /* Called for each cluster when initializing this object.  */
-  void init_cluster (const region2 *base_reg);
+  void init_cluster (const region *base_reg);
 
   /* Lazily mark the cluster containing REG as being reachable, recursively
      adding clusters reachable from REG's cluster.  */
-  void add (const region2 *reg, bool is_mutable);
+  void add (const region *reg, bool is_mutable);
 
-  static void handle_sval_cb (const svalue2 *sval,
-			      reachable_region2s *this_ptr);
+  static void handle_sval_cb (const svalue *sval,
+			      reachable_regions *this_ptr);
 
   /* Add SVAL.  If it is a pointer, add the pointed-to region.  */
-  void handle_sval (const svalue2 *sval);
+  void handle_sval (const svalue *sval);
 
   /* Add SVAL.  If it is a pointer, add the pointed-to region.
      Use PARAM_TYPE for determining mutability.  */
-  void handle_parm (const svalue2 *sval, tree param_type);
+  void handle_parm (const svalue *sval, tree param_type);
 
   /* FIXME.  */
 
   void mark_escaped_clusters (store_manager *mgr);
 
   /* Iteration over reachable regions.  */
-  hash_set<const region2 *>::iterator begin ()
+  hash_set<const region *>::iterator begin ()
   {
     return m_reachable_regs.begin ();
   }
-  hash_set<const region2 *>::iterator end ()
+  hash_set<const region *>::iterator end ()
   {
     return m_reachable_regs.end ();
   }
 
-  hash_set<const svalue2 *>::iterator begin_reachable_svals ()
+  hash_set<const svalue *>::iterator begin_reachable_svals ()
   {
     return m_reachable_svals.begin ();
   }
-  hash_set<const svalue2 *>::iterator end_reachable_svals ()
+  hash_set<const svalue *>::iterator end_reachable_svals ()
   {
     return m_reachable_svals.end ();
   }
-  hash_set<const svalue2 *>::iterator begin_mutable_svals ()
+  hash_set<const svalue *>::iterator begin_mutable_svals ()
   {
     return m_mutable_svals.begin ();
   }
-  hash_set<const svalue2 *>::iterator end_mutable_svals ()
+  hash_set<const svalue *>::iterator end_mutable_svals ()
   {
     return m_mutable_svals.end ();
   }
@@ -91,24 +91,24 @@ public:
 
 private:
   store *m_store;
-  region_model2_manager *m_mgr;
+  region_model_manager *m_mgr;
 
   // FIXME: actually, the clusters
   /* The regions already seen.  */
-  hash_set<const region2 *> m_reachable_regs;
+  hash_set<const region *> m_reachable_regs;
 
   /* The regions that can be changed (accessed via non-const pointers).  */
-  hash_set<const region2 *> m_mutable_regs;
+  hash_set<const region *> m_mutable_regs;
 
   /* svalues that were passed as const pointers, so e.g. couldn't have
      been freed (but could have e.g. had "close" called on them if an
      int file-descriptor).  */
-  hash_set<const svalue2 *> m_reachable_svals;
+  hash_set<const svalue *> m_reachable_svals;
   /* svalues that were passed as non-const pointers, so e.g. could have
      been freed.  */
-  hash_set<const svalue2 *> m_mutable_svals;
+  hash_set<const svalue *> m_mutable_svals;
 };
 
 } // namespace ana
 
-#endif /* GCC_ANALYZER_REGION_MODEL2_REACHABILITY_H */
+#endif /* GCC_ANALYZER_REGION_MODEL_REACHABILITY_H */
diff --git a/gcc/analyzer/sm-file.cc b/gcc/analyzer/sm-file.cc
index 85fbe84999e..f1b3f6c3404 100644
--- a/gcc/analyzer/sm-file.cc
+++ b/gcc/analyzer/sm-file.cc
@@ -56,7 +56,7 @@ public:
   bool inherited_state_p () const FINAL OVERRIDE { return false; }
 
   state_machine::state_t
-  get_default_state (const svalue2 *sval) const FINAL OVERRIDE
+  get_default_state (const svalue *sval) const FINAL OVERRIDE
   {
     if (tree cst = sval->maybe_get_constant ())
       {
diff --git a/gcc/analyzer/sm-malloc.cc b/gcc/analyzer/sm-malloc.cc
index ca51da7f2ab..739139a085f 100644
--- a/gcc/analyzer/sm-malloc.cc
+++ b/gcc/analyzer/sm-malloc.cc
@@ -57,17 +57,17 @@ public:
   bool inherited_state_p () const FINAL OVERRIDE { return false; }
 
   state_machine::state_t
-  get_default_state (const svalue2 *sval) const FINAL OVERRIDE
+  get_default_state (const svalue *sval) const FINAL OVERRIDE
   {
     if (tree cst = sval->maybe_get_constant ())
       {
 	if (zerop (cst))
 	  return m_null;
       }
-    if (const region_svalue2 *ptr = sval->dyn_cast_region_svalue2 ())
+    if (const region_svalue *ptr = sval->dyn_cast_region_svalue ())
       {
-	const region2 *reg = ptr->get_pointee ();
-	if (reg->get_kind () == region2::RK_STRING)
+	const region *reg = ptr->get_pointee ();
+	if (reg->get_kind () == region::RK_STRING)
 	  return m_non_heap;
       }
     return m_start;
diff --git a/gcc/analyzer/sm-signal.cc b/gcc/analyzer/sm-signal.cc
index fd9a5a13fb6..c3ec197cfc2 100644
--- a/gcc/analyzer/sm-signal.cc
+++ b/gcc/analyzer/sm-signal.cc
@@ -204,12 +204,12 @@ signal_state_machine::signal_state_machine (logger *logger)
    an signal-handler in response to a signal.  */
 
 static void
-update_model2_for_signal_handler (region_model2 *model,
-				  function *handler_fun)
+update_model_for_signal_handler (region_model *model,
+				 function *handler_fun)
 {
   gcc_assert (model);
   /* Purge all state within MODEL.  */
-  *model = region_model2 (model->get_manager ());
+  *model = region_model (model->get_manager ());
   model->push_frame (handler_fun, NULL, NULL);
 }
 
@@ -223,10 +223,10 @@ public:
     pp_string (pp, "signal delivered");
   }
 
-  void update_model2 (region_model2 *model,
-		      const exploded_edge &eedge) FINAL OVERRIDE
+  void update_model (region_model *model,
+		     const exploded_edge &eedge) FINAL OVERRIDE
   {
-    update_model2_for_signal_handler (model, eedge.m_dest->get_function ());
+    update_model_for_signal_handler (model, eedge.m_dest->get_function ());
   }
 
   void add_events_to_path (checker_path *emission_path,
@@ -266,9 +266,9 @@ public:
 					    handler_fun);
 
     program_state state_entering_handler (eg->get_ext_state ());
-    update_model2_for_signal_handler (state_entering_handler.m_region_model2,
-				      handler_fun);
-    state_entering_handler.m_checker_states2[sm_idx]->set_global_state
+    update_model_for_signal_handler (state_entering_handler.m_region_model,
+				     handler_fun);
+    state_entering_handler.m_checker_states[sm_idx]->set_global_state
       (m_sm.m_in_signal_handler);
 
     exploded_node *dst_enode = eg->get_or_create_node (entering_handler,
diff --git a/gcc/analyzer/sm.h b/gcc/analyzer/sm.h
index 26be70bd247..fa65f527399 100644
--- a/gcc/analyzer/sm.h
+++ b/gcc/analyzer/sm.h
@@ -52,7 +52,7 @@ public:
      within a heap-allocated struct.  */
   virtual bool inherited_state_p () const = 0;
 
-  virtual state_machine::state_t get_default_state (const svalue2 *) const
+  virtual state_machine::state_t get_default_state (const svalue *) const
   {
     return 0;
   }
diff --git a/gcc/analyzer/store.cc b/gcc/analyzer/store.cc
index b40491ee5b5..1312a01d5f0 100644
--- a/gcc/analyzer/store.cc
+++ b/gcc/analyzer/store.cc
@@ -75,7 +75,7 @@ const char *binding_kind_to_string (enum binding_kind kind)
 /* class binding_key.  */
 
 const binding_key *
-binding_key::make (store_manager *mgr, const region2 *r,
+binding_key::make (store_manager *mgr, const region *r,
 		   enum binding_kind kind)
 {
   region_offset offset = r->get_offset ();
@@ -136,7 +136,7 @@ int
 binding_key::cmp (const binding_key *k1, const binding_key *k2)
 {
 #if 0
-  if (int reg_cmp = region2::cmp_ids (k1->m_region, k2->m_region))
+  if (int reg_cmp = region::cmp_ids (k1->m_region, k2->m_region))
     return reg_cmp;
 #endif
   enum binding_kind kind1 = k1->get_kind ();
@@ -220,7 +220,7 @@ symbolic_binding::dump_to_pp (pretty_printer *pp, bool simple) const
        = MEM <unsigned char[4096]> [(char * {ref-all})&src];
    Using cast_region when handling the MEM_REF would give us:
      INIT_VAL(CAST_REG(unsigned char[4096], src))
-   as rhs_sval, but we can fold that into a cast svalue2:
+   as rhs_sval, but we can fold that into a cast svalue:
      CAST(unsigned char[4096], INIT_VAL(src))
    We can discard that cast from the svalue when binding it in
    the store for "dst", and simply store:
@@ -229,10 +229,10 @@ symbolic_binding::dump_to_pp (pretty_printer *pp, bool simple) const
        value: ‘struct big’ {INIT_VAL(src)}
    FIXME: should we only do this if the sizes are the same?  */
 
-static const svalue2 *
-simplify_for_binding (const svalue2 *sval)
+static const svalue *
+simplify_for_binding (const svalue *sval)
 {
-  if (const svalue2 *cast_sval = sval->maybe_undo_cast ())
+  if (const svalue *cast_sval = sval->maybe_undo_cast ())
     sval = cast_sval;
   return sval;
 }
@@ -257,7 +257,7 @@ binding_map::operator=(const binding_map &other)
        ++iter)
     {
       const binding_key *key = (*iter).first;
-      const svalue2 *sval = (*iter).second;
+      const svalue *sval = (*iter).second;
       m_map.put (key, sval);
     }
   return *this;
@@ -274,8 +274,8 @@ binding_map::operator== (const binding_map &other) const
   for (map_t::iterator iter = m_map.begin (); iter != m_map.end (); ++iter)
     {
       const binding_key *key = (*iter).first;
-      const svalue2 *sval = (*iter).second;
-      const svalue2 **other_slot
+      const svalue *sval = (*iter).second;
+      const svalue **other_slot
 	= const_cast <map_t &> (other.m_map).get (key);
       if (other_slot == NULL)
 	return false;
@@ -304,7 +304,7 @@ binding_map::dump_to_pp (pretty_printer *pp, bool simple,
   unsigned i;
   FOR_EACH_VEC_ELT (binding_keys, i, key)
     {
-      const svalue2 *value = *const_cast <map_t &> (m_map).get (key);
+      const svalue *value = *const_cast <map_t &> (m_map).get (key);
       if (multiline)
 	{
 	  pp_string (pp, "    key:   {");
@@ -346,11 +346,11 @@ binding_map::dump (bool simple) const
   pp_flush (&pp);
 }
 
-/* class binding_cluster2.  */
+/* class binding_cluster.  */
 
 /* FIXME.  */
 
-binding_cluster2::binding_cluster2 (const binding_cluster2 &other)
+binding_cluster::binding_cluster (const binding_cluster &other)
 : m_base_region (other.m_base_region), m_map (other.m_map),
   m_escaped (other.m_escaped), m_touched (other.m_touched)
 {
@@ -358,8 +358,8 @@ binding_cluster2::binding_cluster2 (const binding_cluster2 &other)
 
 /* FIXME.  */
 
-binding_cluster2&
-binding_cluster2::operator= (const binding_cluster2 &other)
+binding_cluster&
+binding_cluster::operator= (const binding_cluster &other)
 {
   gcc_assert (m_base_region == other.m_base_region);
   m_map = other.m_map;
@@ -371,7 +371,7 @@ binding_cluster2::operator= (const binding_cluster2 &other)
 /* FIXME.  */
 
 bool
-binding_cluster2::operator== (const binding_cluster2 &other) const
+binding_cluster::operator== (const binding_cluster &other) const
 {
   if (m_map != other.m_map)
     return false;
@@ -384,16 +384,16 @@ binding_cluster2::operator== (const binding_cluster2 &other) const
 /* FIXME.  */
 
 bool
-binding_cluster2::symbolic_p () const
+binding_cluster::symbolic_p () const
 {
-  return m_base_region->get_kind () == region2::RK_SYMBOLIC;
+  return m_base_region->get_kind () == region::RK_SYMBOLIC;
 }
 
 /* FIXME.  */
 
 void
-binding_cluster2::dump_to_pp (pretty_printer *pp, bool simple,
-			      bool multiline) const
+binding_cluster::dump_to_pp (pretty_printer *pp, bool simple,
+			     bool multiline) const
 {
   if (m_escaped)
     {
@@ -419,10 +419,10 @@ binding_cluster2::dump_to_pp (pretty_printer *pp, bool simple,
   m_map.dump_to_pp (pp, simple, multiline);
 }
 
-/* Dump a multiline representation of this binding_cluster2 to stderr.  */
+/* Dump a multiline representation of this binding_cluster to stderr.  */
 
 DEBUG_FUNCTION void
-binding_cluster2::dump (bool simple) const
+binding_cluster::dump (bool simple) const
 {
   pretty_printer pp;
   pp_format_decoder (&pp) = default_tree_printer;
@@ -440,12 +440,12 @@ binding_cluster2::dump (bool simple) const
 /* FIXME.  */
 
 void
-binding_cluster2::bind (store_manager *mgr,
-			const region2 *reg, const svalue2 *sval,
-			binding_kind kind)
+binding_cluster::bind (store_manager *mgr,
+		       const region *reg, const svalue *sval,
+		       binding_kind kind)
 {
-  if (const compound_svalue2 *compound_sval
-	= sval->dyn_cast_compound_svalue2 ())
+  if (const compound_svalue *compound_sval
+	= sval->dyn_cast_compound_svalue ())
     {
       bind_compound_sval (mgr, reg, compound_sval);
       return;
@@ -458,24 +458,24 @@ binding_cluster2::bind (store_manager *mgr,
 /* FIXME.  */
 
 void
-binding_cluster2::bind_key (const binding_key *key, const svalue2 *sval)
+binding_cluster::bind_key (const binding_key *key, const svalue *sval)
 {
-  /* Unpacking of compound_svalue2 should have been done by now.  */
-  gcc_assert (sval->get_kind () != svalue2::SK_COMPOUND);
+  /* Unpacking of compound_svalue should have been done by now.  */
+  gcc_assert (sval->get_kind () != svalue::SK_COMPOUND);
 
   m_map.put (key, sval);
   if (key->symbolic_p ())
     m_touched = true;
 }
 
-/* Subroutine of binding_cluster2::bind.
+/* Subroutine of binding_cluster::bind.
    Unpack compound_svals when binding them, so that we bind them
    element-wise.  */
 
 void
-binding_cluster2::bind_compound_sval (store_manager *mgr,
-				      const region2 *reg,
-				      const compound_svalue2 *compound_sval)
+binding_cluster::bind_compound_sval (store_manager *mgr,
+				     const region *reg,
+				     const compound_svalue *compound_sval)
 {
   region_offset reg_offset = reg->get_offset ();
   if (reg_offset.symbolic_p ())
@@ -493,7 +493,7 @@ binding_cluster2::bind_compound_sval (store_manager *mgr,
        iter != compound_sval->end (); ++iter)
     {
       const binding_key *iter_key = (*iter).first;
-      const svalue2 *iter_sval = (*iter).second;
+      const svalue *iter_sval = (*iter).second;
 
       if (const concrete_binding *concrete_key
 	  = iter_key->dyn_cast_concrete_binding ())
@@ -515,7 +515,7 @@ binding_cluster2::bind_compound_sval (store_manager *mgr,
 /* Remove all bindings affecting REG within this cluster.  */
 
 void
-binding_cluster2::clobber_region (store_manager *mgr, const region2 *reg)
+binding_cluster::clobber_region (store_manager *mgr, const region *reg)
 {
   remove_overlapping_bindings (mgr, reg);
 }
@@ -523,11 +523,11 @@ binding_cluster2::clobber_region (store_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-binding_cluster2::purge_region (store_manager *mgr, const region2 *reg)
+binding_cluster::purge_region (store_manager *mgr, const region *reg)
 {
-  gcc_assert (reg->get_kind () == region2::RK_DECL);
+  gcc_assert (reg->get_kind () == region::RK_DECL);
   const binding_key *binding
-    = binding_key::make (mgr, const_cast<region2 *> (reg),
+    = binding_key::make (mgr, const_cast<region *> (reg),
 			 BK_direct);
   m_map.remove (binding);
 }
@@ -537,15 +537,15 @@ binding_cluster2::purge_region (store_manager *mgr, const region2 *reg)
    TOUCHED flag.  */
 
 void
-binding_cluster2::zero_fill_region (store_manager *mgr, const region2 *reg)
+binding_cluster::zero_fill_region (store_manager *mgr, const region *reg)
 {
   clobber_region (mgr, reg);
 
   /* Add a default binding to zero.  */
-  region_model2_manager *sval_mgr = mgr->get_svalue2_manager ();
+  region_model_manager *sval_mgr = mgr->get_svalue_manager ();
   tree cst_zero = build_int_cst (integer_type_node, 0);
-  const svalue2 *cst_sval = sval_mgr->get_or_create_constant_svalue2 (cst_zero);
-  const svalue2 *bound_sval = cst_sval;
+  const svalue *cst_sval = sval_mgr->get_or_create_constant_svalue (cst_zero);
+  const svalue *bound_sval = cst_sval;
   if (reg->get_type ())
     bound_sval = sval_mgr->get_or_create_unaryop (reg->get_type (), NOP_EXPR,
 						  cst_sval);
@@ -558,27 +558,27 @@ binding_cluster2::zero_fill_region (store_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-binding_cluster2::mark_region_as_unknown (store_manager *mgr,
-					  const region2 *reg)
+binding_cluster::mark_region_as_unknown (store_manager *mgr,
+					 const region *reg)
 {
   remove_overlapping_bindings (mgr, reg);
 
   /* Add a default binding to "unknown".  */
-  region_model2_manager *sval_mgr = mgr->get_svalue2_manager ();
-  const svalue2 *sval
-    = sval_mgr->get_or_create_unknown_svalue2 (reg->get_type ());
+  region_model_manager *sval_mgr = mgr->get_svalue_manager ();
+  const svalue *sval
+    = sval_mgr->get_or_create_unknown_svalue (reg->get_type ());
   bind (mgr, reg, sval, BK_default);
 }
 
 /* FIXME.  */
 
-const svalue2 *
-binding_cluster2::get_binding (store_manager *mgr,
-			       const region2 *reg,
-			       binding_kind kind) const
+const svalue *
+binding_cluster::get_binding (store_manager *mgr,
+			      const region *reg,
+			      binding_kind kind) const
 {
   const binding_key *reg_binding = binding_key::make (mgr, reg, kind);
-  const svalue2 *sval = m_map.get (reg_binding);
+  const svalue *sval = m_map.get (reg_binding);
   if (sval)
     {
       /* If we have a struct with a single field, then the binding of
@@ -591,8 +591,8 @@ binding_cluster2::get_binding (store_manager *mgr,
 	 expressing the lookups as subvalues.
 	 We have to gather a list of subregion accesses, then walk it
 	 in reverse to get the subvalues.  */
-      auto_vec<const region2 *> regions;
-      while (const region2 *parent_reg = reg->get_parent_region ())
+      auto_vec<const region *> regions;
+      while (const region *parent_reg = reg->get_parent_region ())
 	{
 	  const binding_key *parent_reg_binding
 	    = binding_key::make (mgr, parent_reg, kind);
@@ -612,12 +612,12 @@ binding_cluster2::get_binding (store_manager *mgr,
 	  && sval->get_type () == reg->get_type ())
 	{
 	  unsigned i;
-	  const region2 *iter_reg;
+	  const region *iter_reg;
 	  FOR_EACH_VEC_ELT_REVERSE (regions, i, iter_reg)
 	    {
-	      region_model2_manager *rmm_mgr = mgr->get_svalue2_manager ();
-	      sval = rmm_mgr->get_or_create_sub_svalue2 (reg->get_type (),
-							 sval, iter_reg);
+	      region_model_manager *rmm_mgr = mgr->get_svalue_manager ();
+	      sval = rmm_mgr->get_or_create_sub_svalue (reg->get_type (),
+							sval, iter_reg);
 	    }
 	}
     }
@@ -626,31 +626,31 @@ binding_cluster2::get_binding (store_manager *mgr,
 
 /* FIXME.  */
 
-const svalue2 *
-binding_cluster2::get_binding_recursive (store_manager *mgr,
-					 const region2 *reg,
-					 enum binding_kind kind) const
+const svalue *
+binding_cluster::get_binding_recursive (store_manager *mgr,
+					const region *reg,
+					enum binding_kind kind) const
 {
-  if (const svalue2 *sval = get_binding (mgr, reg, kind))
+  if (const svalue *sval = get_binding (mgr, reg, kind))
     return sval;
   if (reg != m_base_region)
-    if (const region2 *parent_reg = reg->get_parent_region ())
-      if (const svalue2 *parent_sval
+    if (const region *parent_reg = reg->get_parent_region ())
+      if (const svalue *parent_sval
 	  = get_binding_recursive (mgr, parent_reg, kind))
 	{
 	  /* Extract child svalue from parent svalue.  */
-	  region_model2_manager *rmm_mgr = mgr->get_svalue2_manager ();
-	  return rmm_mgr->get_or_create_sub_svalue2 (reg->get_type (),
-						     parent_sval, reg);
+	  region_model_manager *rmm_mgr = mgr->get_svalue_manager ();
+	  return rmm_mgr->get_or_create_sub_svalue (reg->get_type (),
+						    parent_sval, reg);
 	}
   return NULL;
 }
 
 /* FIXME.  */
 
-const svalue2 *
-binding_cluster2::get_any_binding (store_manager *mgr,
-				   const region2 *reg) const
+const svalue *
+binding_cluster::get_any_binding (store_manager *mgr,
+				  const region *reg) const
 {
   /* FIXME:  I'm not quite sure how this should work.
      This looks recursively for matches for a "direct" binding,
@@ -661,13 +661,13 @@ binding_cluster2::get_any_binding (store_manager *mgr,
      But when should bindings be default, and when should they be direct?
      The code uses "default" for things that are typically a parent
      region, and "direct" elsewhere.  */
-  if (const svalue2 *direct_sval
+  if (const svalue *direct_sval
       = get_binding_recursive (mgr, reg, BK_direct))
     return direct_sval;
 
   /* Don't use "default" bindings if there's been a symbolic write.  */
   if (!m_touched)
-    if (const svalue2 *default_sval
+    if (const svalue *default_sval
 	= get_binding_recursive (mgr, reg, BK_default))
       return default_sval;
 
@@ -675,32 +675,32 @@ binding_cluster2::get_any_binding (store_manager *mgr,
      of any subregion not currently specifically bound is "UNKNOWN".  */
   if (m_touched)
     {
-      region_model2_manager *rmm_mgr = mgr->get_svalue2_manager ();
-      return rmm_mgr->get_or_create_unknown_svalue2 (reg->get_type ());
+      region_model_manager *rmm_mgr = mgr->get_svalue_manager ();
+      return rmm_mgr->get_or_create_unknown_svalue (reg->get_type ());
     }
 
   /* TODO: WIP.  */
-  if (const svalue2 *compound_sval = maybe_get_compound_binding (mgr, reg))
+  if (const svalue *compound_sval = maybe_get_compound_binding (mgr, reg))
     return compound_sval;
 
   /* Otherwise, the initial value, or uninitialized.  */
   return NULL;
 }
 
-/* Attempt to get a compound_svalue2 for the bindings within the cluster
+/* Attempt to get a compound_svalue for the bindings within the cluster
    affecting REG (which could be the base region itself).
 
-   Create a compound_svalue2 with the subset of bindings the affect REG,
+   Create a compound_svalue with the subset of bindings the affect REG,
    offsetting them so that the offsets are relative to the start of REG
    within the cluster.
 
    For example, REG could be one element within an array of structs.
 
-   Return the resulting compound_svalue2, or NULL if there's a problem.  */
+   Return the resulting compound_svalue, or NULL if there's a problem.  */
 
-const svalue2 *
-binding_cluster2::maybe_get_compound_binding (store_manager *mgr,
-					      const region2 *reg) const
+const svalue *
+binding_cluster::maybe_get_compound_binding (store_manager *mgr,
+					     const region *reg) const
 {
   binding_map map;
 
@@ -714,7 +714,7 @@ binding_cluster2::maybe_get_compound_binding (store_manager *mgr,
   for (map_t::iterator iter = m_map.begin (); iter != m_map.end (); ++iter)
     {
       const binding_key *key = (*iter).first;
-      const svalue2 *sval = (*iter).second;
+      const svalue *sval = (*iter).second;
 
       if (const concrete_binding *concrete_key
 	  = key->dyn_cast_concrete_binding ())
@@ -747,17 +747,17 @@ binding_cluster2::maybe_get_compound_binding (store_manager *mgr,
   if (map.elements () == 0)
     return NULL;
 
-  region_model2_manager *sval_mgr = mgr->get_svalue2_manager ();
-  return sval_mgr->get_or_create_compound_svalue2 (reg->get_type (), map);
+  region_model_manager *sval_mgr = mgr->get_svalue_manager ();
+  return sval_mgr->get_or_create_compound_svalue (reg->get_type (), map);
 }
 
 
 /* Populate OUT with all bindings within this cluster that overlap REG.  */
 
 void
-binding_cluster2::get_overlapping_bindings (store_manager *mgr,
-					    const region2 *reg,
-					    auto_vec<const binding_key *> *out)
+binding_cluster::get_overlapping_bindings (store_manager *mgr,
+					   const region *reg,
+					   auto_vec<const binding_key *> *out)
 {
   /* Get the size of REG.  */
   // TODO
@@ -794,8 +794,8 @@ binding_cluster2::get_overlapping_bindings (store_manager *mgr,
 /* FIXME.  */
 
 void
-binding_cluster2::remove_overlapping_bindings (store_manager *mgr,
-					       const region2 *reg)
+binding_cluster::remove_overlapping_bindings (store_manager *mgr,
+					      const region *reg)
 {
   auto_vec<const binding_key *> bindings;
   get_overlapping_bindings (mgr, reg, &bindings);
@@ -823,11 +823,11 @@ binding_cluster2::remove_overlapping_bindings (store_manager *mgr,
 /* FIXME.  */
 
 bool
-binding_cluster2::can_merge_p (const binding_cluster2 *cluster_a,
-			       const binding_cluster2 *cluster_b,
-			       binding_cluster2 *out_cluster,
-			       store_manager *mgr,
-			       model2_merger *merger)
+binding_cluster::can_merge_p (const binding_cluster *cluster_a,
+			      const binding_cluster *cluster_b,
+			      binding_cluster *out_cluster,
+			      store_manager *mgr,
+			      model_merger *merger)
 {
   gcc_assert (out_cluster);
 
@@ -879,8 +879,8 @@ binding_cluster2::can_merge_p (const binding_cluster2 *cluster_a,
        iter != keys.end (); ++iter)
     {
       const binding_key *key = *iter;
-      const svalue2 *sval_a = cluster_a->get_any_value (key);
-      const svalue2 *sval_b = cluster_b->get_any_value (key);
+      const svalue *sval_a = cluster_a->get_any_value (key);
+      const svalue *sval_b = cluster_b->get_any_value (key);
 
       if (sval_a == sval_b)
 	{
@@ -890,8 +890,8 @@ binding_cluster2::can_merge_p (const binding_cluster2 *cluster_a,
 	}
       else if (sval_a && sval_b)
 	{
-	  region_model2_manager *sval_mgr = mgr->get_svalue2_manager ();
-	  if (const svalue2 *merged_sval
+	  region_model_manager *sval_mgr = mgr->get_svalue_manager ();
+	  if (const svalue *merged_sval
 	      = sval_a->can_merge_p (sval_b, sval_mgr, merger))
 	    {
 	      out_cluster->m_map.put (key, merged_sval);
@@ -905,8 +905,8 @@ binding_cluster2::can_merge_p (const binding_cluster2 *cluster_a,
 	 doesn't; merge them as "UNKNOWN".  */
       gcc_assert (sval_a || sval_b);
       tree type = sval_a ? sval_a->get_type () : sval_b->get_type ();
-      const svalue2 *unknown_sval
-	= mgr->get_svalue2_manager ()->get_or_create_unknown_svalue2 (type);
+      const svalue *unknown_sval
+	= mgr->get_svalue_manager ()->get_or_create_unknown_svalue (type);
       out_cluster->m_map.put (key, unknown_sval);
     }
   // FIXME: what about overlaps?
@@ -921,16 +921,16 @@ binding_cluster2::can_merge_p (const binding_cluster2 *cluster_a,
    Any bound keys in OTHER should be bound to unknown in this.  */
 
 void
-binding_cluster2::make_unknown_relative_to (const binding_cluster2 *other,
-					    store_manager *mgr)
+binding_cluster::make_unknown_relative_to (const binding_cluster *other,
+					   store_manager *mgr)
 {
   for (map_t::iterator iter = other->m_map.begin ();
        iter != other->m_map.end (); ++iter)
     {
       const binding_key *iter_key = (*iter).first;
-      const svalue2 *iter_sval = (*iter).second;
-      const svalue2 *unknown_sval
-	= mgr->get_svalue2_manager ()->get_or_create_unknown_svalue2
+      const svalue *iter_sval = (*iter).second;
+      const svalue *unknown_sval
+	= mgr->get_svalue_manager ()->get_or_create_unknown_svalue
 	  (iter_sval->get_type ());
       m_map.put (iter_key, unknown_sval);
     }
@@ -939,7 +939,7 @@ binding_cluster2::make_unknown_relative_to (const binding_cluster2 *other,
 /* Mark this cluster as having escaped.  */
 
 void
-binding_cluster2::mark_as_escaped ()
+binding_cluster::mark_as_escaped ()
 {
   /* TODO: but maybe not if it's a global?
      they have automatically escaped already, and we want to be able
@@ -953,11 +953,11 @@ binding_cluster2::mark_as_escaped ()
 /* If this cluster has escaped (by this call, or by an earlier one, or
    by being an external param), then unbind all values and mark it
    as "touched", so that it has an unknown value, rather than an
-   initial_svalue2.  */
+   initial_svalue.  */
 
 void
-binding_cluster2::on_unknown_fncall (const gcall *call,
-				     store_manager *mgr)
+binding_cluster::on_unknown_fncall (const gcall *call,
+				    store_manager *mgr)
 {
   if (m_escaped)
     {
@@ -965,8 +965,8 @@ binding_cluster2::on_unknown_fncall (const gcall *call,
 
 #if CONJURED_VALUES_FOR_UNKNOWN_FNCALLS
       // TODO: bind it to a new "conjured" value using CALL
-      const svalue2 *sval
-	= mgr->get_svalue2_manager ()->get_or_create_conjured_svalue2
+      const svalue *sval
+	= mgr->get_svalue_manager ()->get_or_create_conjured_svalue
 	    (m_base_region->get_type (), call, m_base_region);
       bind (mgr, m_base_region, sval, BK_direct);
 #endif
@@ -975,12 +975,12 @@ binding_cluster2::on_unknown_fncall (const gcall *call,
     }
 }
 
-/* Return true if this binding_cluster2 has no information
+/* Return true if this binding_cluster has no information
    i.e. if there are no bindings, and it hasn't been marked as having
    escaped, or touched symbolically.  */
 
 bool
-binding_cluster2::redundant_p () const
+binding_cluster::redundant_p () const
 {
   return (m_map.elements () == 0
 	  && !m_escaped
@@ -991,11 +991,11 @@ binding_cluster2::redundant_p () const
    appending the results to OUT_PVS.  */
 
 void
-binding_cluster2::get_representative_path_vars (const region_model2 *model,
-						hash_set <const svalue2 *> *visited,
-						const region2 *base_reg,
-						const svalue2 *sval,
-						auto_vec<path_var> *out_pvs)
+binding_cluster::get_representative_path_vars (const region_model *model,
+					       hash_set <const svalue *> *visited,
+					       const region *base_reg,
+					       const svalue *sval,
+					       auto_vec<path_var> *out_pvs)
   const
 {
   sval = simplify_for_binding (sval);
@@ -1003,13 +1003,13 @@ binding_cluster2::get_representative_path_vars (const region_model2 *model,
   for (map_t::iterator iter = m_map.begin (); iter != m_map.end (); ++iter)
     {
       const binding_key *key = (*iter).first;
-      const svalue2 *bound_sval = (*iter).second;
+      const svalue *bound_sval = (*iter).second;
       if (bound_sval == sval)
 	{
 	  if (const concrete_binding *ckey
 		= key->dyn_cast_concrete_binding ())
 	    {
-	      auto_vec <const region2 *> subregions;
+	      auto_vec <const region *> subregions;
 	      base_reg->get_subregions_for_binding
 		(model->get_manager (),
 		 ckey->get_start_bit_offset (),
@@ -1017,7 +1017,7 @@ binding_cluster2::get_representative_path_vars (const region_model2 *model,
 		 sval->get_type (),
 		 &subregions);
 	      unsigned i;
-	      const region2 *subregion;
+	      const region *subregion;
 	      FOR_EACH_VEC_ELT (subregions, i, subregion)
 		{
 		  if (path_var pv
@@ -1040,8 +1040,8 @@ binding_cluster2::get_representative_path_vars (const region_model2 *model,
 
 /* FIXME.  */
 
-const svalue2 *
-binding_cluster2::get_any_value (const binding_key *key) const
+const svalue *
+binding_cluster::get_any_value (const binding_key *key) const
 {
   return m_map.get (key);
 }
@@ -1050,8 +1050,8 @@ binding_cluster2::get_any_value (const binding_key *key) const
    return it.
    For use in simplifying dumps.  */
 
-const svalue2 *
-binding_cluster2::maybe_get_simple_value (store_manager *mgr) const
+const svalue *
+binding_cluster::maybe_get_simple_value (store_manager *mgr) const
 {
   /* Fail gracefully if MGR is NULL to make it easier to dump store
      instances in the debugger.  */
@@ -1080,7 +1080,7 @@ store_manager::get_concrete_binding (bit_offset_t start_bit_offset,
 }
 
 const symbolic_binding *
-store_manager::get_symbolic_binding (const region2 *reg,
+store_manager::get_symbolic_binding (const region *reg,
 				     enum binding_kind kind)
 {
   symbolic_binding *b = new symbolic_binding (reg, kind);
@@ -1106,11 +1106,11 @@ store::store (const store &other)
        iter != other.m_cluster_map.end ();
        ++iter)
     {
-      const region2 *reg = (*iter).first;
+      const region *reg = (*iter).first;
       gcc_assert (reg);
-      binding_cluster2 *c = (*iter).second;
+      binding_cluster *c = (*iter).second;
       gcc_assert (c);
-      m_cluster_map.put (reg, new binding_cluster2 (*c));
+      m_cluster_map.put (reg, new binding_cluster (*c));
     }
 }
 
@@ -1143,11 +1143,11 @@ store::operator= (const store &other)
        iter != other.m_cluster_map.end ();
        ++iter)
     {
-      const region2 *reg = (*iter).first;
+      const region *reg = (*iter).first;
       gcc_assert (reg);
-      binding_cluster2 *c = (*iter).second;
+      binding_cluster *c = (*iter).second;
       gcc_assert (c);
-      m_cluster_map.put (reg, new binding_cluster2 (*c));
+      m_cluster_map.put (reg, new binding_cluster (*c));
     }
   return *this;
 }
@@ -1167,9 +1167,9 @@ store::operator== (const store &other) const
        iter != m_cluster_map.end ();
        ++iter)
     {
-      const region2 *reg = (*iter).first;
-      binding_cluster2 *c = (*iter).second;
-      binding_cluster2 **other_slot
+      const region *reg = (*iter).first;
+      binding_cluster *c = (*iter).second;
+      binding_cluster **other_slot
 	= const_cast <cluster_map_t &> (other.m_cluster_map).get (reg);
       if (other_slot == NULL)
 	return false;
@@ -1182,27 +1182,27 @@ store::operator== (const store &other) const
 /* FIXME.  */
 
 static void
-get_sorted_parent_regions (auto_vec<const region2 *> *out,
-			   auto_vec<const region2 *> &in)
+get_sorted_parent_regions (auto_vec<const region *> *out,
+			   auto_vec<const region *> &in)
 {
   /* Get the set of parent regions.  */
-  hash_set<const region2 *> parent_regions;
-  const region2 *iter_reg;
+  hash_set<const region *> parent_regions;
+  const region *iter_reg;
   unsigned i;
   FOR_EACH_VEC_ELT (in, i, iter_reg)
     {
-      const region2 *parent_reg = iter_reg->get_parent_region ();
+      const region *parent_reg = iter_reg->get_parent_region ();
       gcc_assert (parent_reg);
       parent_regions.add (parent_reg);
     }
 
   /* Write to OUT.  */
-  for (hash_set<const region2 *>::iterator iter = parent_regions.begin();
+  for (hash_set<const region *>::iterator iter = parent_regions.begin();
        iter != parent_regions.end(); ++iter)
     out->safe_push (*iter);
 
   /* Sort OUT.  */
-  out->qsort (region2::cmp_ptrs);
+  out->qsort (region::cmp_ptrs);
 }
 
 /* FIXME.
@@ -1214,21 +1214,21 @@ 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;
+  auto_vec<const region *> base_regions;
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
        iter != m_cluster_map.end (); ++iter)
     {
-      const region2 *base_reg = (*iter).first;
+      const region *base_reg = (*iter).first;
       base_regions.safe_push (base_reg);
     }
-  base_regions.qsort (region2::cmp_ptrs);
+  base_regions.qsort (region::cmp_ptrs);
 
   /* Gather clusters, organize by parent region, so that we can group
      together locals, globals, etc.  */
-  auto_vec<const region2 *> parent_regions;
+  auto_vec<const region *> parent_regions;
   get_sorted_parent_regions (&parent_regions, base_regions);
 
-  const region2 *parent_reg;
+  const region *parent_reg;
   unsigned i;
   FOR_EACH_VEC_ELT (parent_regions, i, parent_reg)
     {
@@ -1240,21 +1240,21 @@ store::dump_to_pp (pretty_printer *pp, bool simple, bool multiline,
       else
 	pp_string (pp, " {");
 
-      const region2 *base_reg;
+      const region *base_reg;
       unsigned j;
       FOR_EACH_VEC_ELT (base_regions, j, base_reg)
 	{
 	  /* This is O(N * M), but N ought to be small.  */
 	  if (base_reg->get_parent_region () != parent_reg)
 	    continue;
-	  binding_cluster2 *cluster
+	  binding_cluster *cluster
 	    = *const_cast<cluster_map_t &> (m_cluster_map).get (base_reg);
 	  if (!multiline)
 	    {
 	      if (j > 0)
 		pp_string (pp, ", ");
 	    }
-	  if (const svalue2 *sval = cluster->maybe_get_simple_value (mgr))
+	  if (const svalue *sval = cluster->maybe_get_simple_value (mgr))
 	    {
 	      /* Special-case to simplify dumps for the common case where
 		 we just have one value directly bound to the whole of a
@@ -1332,21 +1332,21 @@ store::summarize_to_pp (pretty_printer *pp, bool simple) const
   // TODO
 #else
   /* Sort into some deterministic order.  */
-  auto_vec<const region2 *> base_regions;
+  auto_vec<const region *> base_regions;
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
        iter != m_cluster_map.end (); ++iter)
     {
-      const region2 *base_reg = (*iter).first;
+      const region *base_reg = (*iter).first;
       base_regions.safe_push (base_reg);
     }
-  base_regions.qsort (region2::cmp_ptrs);
+  base_regions.qsort (region::cmp_ptrs);
 
   /* Gather clusters, organize by parent region, so that we can group
      together locals, globals, etc.  */
-  auto_vec<const region2 *> parent_regions;
+  auto_vec<const region *> parent_regions;
   get_sorted_parent_regions (&parent_regions, base_regions);
 
-  const region2 *parent_reg;
+  const region *parent_reg;
   unsigned i;
   FOR_EACH_VEC_ELT (parent_regions, i, parent_reg)
     {
@@ -1354,14 +1354,14 @@ store::summarize_to_pp (pretty_printer *pp, bool simple) const
       pp_string (pp, "clusters within ");
       parent_reg->dump_to_pp (pp, simple);
 
-      const region2 *base_reg;
+      const region *base_reg;
       unsigned j;
       FOR_EACH_VEC_ELT (base_regions, j, base_reg)
 	{
 	  /* This is O(N * M), but N ought to be small.  */
 	  if (base_reg->get_parent_region () != parent_reg)
 	    continue;
-	  binding_cluster2 *cluster
+	  binding_cluster *cluster
 	    = *const_cast<cluster_map_t &> (m_cluster_map).get (base_reg);
 	  if (multiline)
 	    {
@@ -1385,11 +1385,11 @@ store::summarize_to_pp (pretty_printer *pp, bool simple) const
 
 /* FIXME.  */
 
-const svalue2 *
-store::get_any_binding (store_manager *mgr, const region2 *reg) const
+const svalue *
+store::get_any_binding (store_manager *mgr, const region *reg) const
 {
-  const region2 *base_reg = reg->get_base_region ();
-  binding_cluster2 **cluster_slot
+  const region *base_reg = reg->get_base_region ();
+  binding_cluster **cluster_slot
     = const_cast <cluster_map_t &> (m_cluster_map).get (base_reg);
   if (!cluster_slot)
     return NULL;
@@ -1399,15 +1399,15 @@ store::get_any_binding (store_manager *mgr, const region2 *reg) const
 /* FIXME.  */
 
 void
-store::set_value (store_manager *mgr, const region2 *lhs_reg,
-		  const svalue2 *rhs_sval, enum binding_kind kind)
+store::set_value (store_manager *mgr, const region *lhs_reg,
+		  const svalue *rhs_sval, enum binding_kind kind)
 {
   remove_overlapping_bindings (mgr, lhs_reg);
 
   rhs_sval = simplify_for_binding (rhs_sval);
 
-  const region2 *lhs_base_reg = lhs_reg->get_base_region ();
-  binding_cluster2 *lhs_cluster;
+  const region *lhs_base_reg = lhs_reg->get_base_region ();
+  binding_cluster *lhs_cluster;
   if (lhs_base_reg->symbolic_for_unknown_ptr_p ())
     /* Reject attempting to bind values into a symbolic region
        for an unknown ptr; merely invalidate values below.  */
@@ -1435,8 +1435,8 @@ store::set_value (store_manager *mgr, const region2 *lhs_reg,
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
        iter != m_cluster_map.end (); ++iter)
     {
-      const region2 *iter_base_reg = (*iter).first;
-      binding_cluster2 *iter_cluster = (*iter).second;
+      const region *iter_base_reg = (*iter).first;
+      binding_cluster *iter_cluster = (*iter).second;
       if (iter_base_reg != lhs_base_reg
 	  && (lhs_cluster == NULL
 	      || lhs_cluster->symbolic_p ()
@@ -1478,8 +1478,8 @@ store::set_value (store_manager *mgr, const region2 *lhs_reg,
 /* Determine if BASE_REG_A could be an alias of BASE_REG_B.  */
 
 tristate
-store::eval_alias (const region2 *base_reg_a,
-		   const region2 *base_reg_b)
+store::eval_alias (const region *base_reg_a,
+		   const region *base_reg_b)
 {
   /* SSA names can't alias.  */
   tree decl_a = base_reg_a->maybe_get_decl ();
@@ -1489,11 +1489,11 @@ store::eval_alias (const region2 *base_reg_a,
   if (decl_b && TREE_CODE (decl_b) == SSA_NAME)
     return tristate::TS_FALSE;
 
-  if (const symbolic_region2 *sym_reg_a
-      = base_reg_a->dyn_cast_symbolic_region2 ())
+  if (const symbolic_region *sym_reg_a
+      = base_reg_a->dyn_cast_symbolic_region ())
     {
-      const svalue2 *sval_a = sym_reg_a->get_pointer ();
-      if (sval_a->get_kind () == svalue2::SK_INITIAL
+      const svalue *sval_a = sym_reg_a->get_pointer ();
+      if (sval_a->get_kind () == svalue::SK_INITIAL
 	  && decl_b
 	  && !is_global_var (decl_b))
 	{
@@ -1501,11 +1501,11 @@ store::eval_alias (const region2 *base_reg_a,
 	  return tristate::TS_FALSE;
 	}
     }
-  if (const symbolic_region2 *sym_reg_b
-      = base_reg_b->dyn_cast_symbolic_region2 ())
+  if (const symbolic_region *sym_reg_b
+      = base_reg_b->dyn_cast_symbolic_region ())
     {
-      const svalue2 *sval_b = sym_reg_b->get_pointer ();
-      if (sval_b->get_kind () == svalue2::SK_INITIAL
+      const svalue *sval_b = sym_reg_b->get_pointer ();
+      if (sval_b->get_kind () == svalue::SK_INITIAL
 	  && decl_a
 	  && !is_global_var (decl_a))
 	{
@@ -1525,13 +1525,13 @@ store::eval_alias (const region2 *base_reg_a,
 /* FIXME.  */
 
 void
-store::clobber_region (store_manager *mgr, const region2 *reg)
+store::clobber_region (store_manager *mgr, const region *reg)
 {
-  const region2 *base_reg = reg->get_base_region ();
-  binding_cluster2 **slot = m_cluster_map.get (base_reg);
+  const region *base_reg = reg->get_base_region ();
+  binding_cluster **slot = m_cluster_map.get (base_reg);
   if (!slot)
     return;
-  binding_cluster2 *cluster = *slot;
+  binding_cluster *cluster = *slot;
   cluster->clobber_region (mgr, reg);
   if (cluster->redundant_p ())
     {
@@ -1543,13 +1543,13 @@ store::clobber_region (store_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-store::purge_region (store_manager *mgr, const region2 *reg)
+store::purge_region (store_manager *mgr, const region *reg)
 {
-  const region2 *base_reg = reg->get_base_region ();
-  binding_cluster2 **slot = m_cluster_map.get (base_reg);
+  const region *base_reg = reg->get_base_region ();
+  binding_cluster **slot = m_cluster_map.get (base_reg);
   if (!slot)
     return;
-  binding_cluster2 *cluster = *slot;
+  binding_cluster *cluster = *slot;
   cluster->purge_region (mgr, reg);
   if (cluster->redundant_p ())
     {
@@ -1561,37 +1561,37 @@ store::purge_region (store_manager *mgr, const region2 *reg)
 /* FIXME.  */
 
 void
-store::zero_fill_region (store_manager *mgr, const region2 *reg)
+store::zero_fill_region (store_manager *mgr, const region *reg)
 {
-  const region2 *base_reg = reg->get_base_region ();
+  const region *base_reg = reg->get_base_region ();
   if (base_reg->symbolic_for_unknown_ptr_p ())
     // FIXME: should we also invalidate existing clusters?
     return;
-  binding_cluster2 *cluster = get_or_create_cluster (base_reg);
+  binding_cluster *cluster = get_or_create_cluster (base_reg);
   cluster->zero_fill_region (mgr, reg);
 }
 
 /* FIXME.  */
 
 void
-store::mark_region_as_unknown (store_manager *mgr, const region2 *reg)
+store::mark_region_as_unknown (store_manager *mgr, const region *reg)
 {
-  const region2 *base_reg = reg->get_base_region ();
+  const region *base_reg = reg->get_base_region ();
   if (base_reg->symbolic_for_unknown_ptr_p ())
     // FIXME: should we also invalidate existing clusters?
     return;
-  binding_cluster2 *cluster = get_or_create_cluster (base_reg);
+  binding_cluster *cluster = get_or_create_cluster (base_reg);
   cluster->mark_region_as_unknown (mgr, reg);
 }
 
 /* FIXME.  */
 
-const binding_cluster2 *
-store::get_cluster (const region2 *base_reg) const
+const binding_cluster *
+store::get_cluster (const region *base_reg) const
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
-  if (binding_cluster2 **slot
+  if (binding_cluster **slot
         = const_cast <cluster_map_t &> (m_cluster_map).get (base_reg))
     return *slot;
   else
@@ -1600,12 +1600,12 @@ store::get_cluster (const region2 *base_reg) const
 
 /* FIXME.  */
 
-binding_cluster2 *
-store::get_cluster (const region2 *base_reg)
+binding_cluster *
+store::get_cluster (const region *base_reg)
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
-  if (binding_cluster2 **slot = m_cluster_map.get (base_reg))
+  if (binding_cluster **slot = m_cluster_map.get (base_reg))
     return *slot;
   else
     return NULL;
@@ -1613,8 +1613,8 @@ store::get_cluster (const region2 *base_reg)
 
 /* FIXME.  */
 
-binding_cluster2 *
-store::get_or_create_cluster (const region2 *base_reg)
+binding_cluster *
+store::get_or_create_cluster (const region *base_reg)
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
@@ -1622,10 +1622,10 @@ store::get_or_create_cluster (const region2 *base_reg)
   /* We shouldn't create clusters for dereferencing an UNKNOWN ptr.  */
   gcc_assert (!base_reg->symbolic_for_unknown_ptr_p ());
 
-  if (binding_cluster2 **slot = m_cluster_map.get (base_reg))
+  if (binding_cluster **slot = m_cluster_map.get (base_reg))
     return *slot;
 
-  binding_cluster2 *cluster = new binding_cluster2 (base_reg);
+  binding_cluster *cluster = new binding_cluster (base_reg);
   m_cluster_map.put (base_reg, cluster);
   // FIXME: can this directly go in *slot ?
 
@@ -1633,17 +1633,17 @@ store::get_or_create_cluster (const region2 *base_reg)
 }
 
 /* Remove any cluster for BASE_REG, for use by
-   region_model2::unbind_region2_and_descendents
+   region_model::unbind_region_and_descendents
    when popping stack frames and handling deleted heap regions.  */
 
 void
-store::purge_cluster (const region2 *base_reg)
+store::purge_cluster (const region *base_reg)
 {
   gcc_assert (base_reg->get_base_region () == base_reg);
-  binding_cluster2 **slot = m_cluster_map.get (base_reg);
+  binding_cluster **slot = m_cluster_map.get (base_reg);
   if (!slot)
     return;
-  binding_cluster2 *cluster = *slot;
+  binding_cluster *cluster = *slot;
   delete cluster;
   m_cluster_map.remove (base_reg);
 }
@@ -1653,37 +1653,37 @@ store::purge_cluster (const region2 *base_reg)
 bool
 store::can_merge_p (const store *store_a, const store *store_b,
 		    store *out_store, store_manager *mgr,
-		    model2_merger *merger)
+		    model_merger *merger)
 {
   if (store_a->m_called_unknown_fn || store_b->m_called_unknown_fn)
     out_store->m_called_unknown_fn = true;
 
   /* Get the union of all base regions for STORE_A and STORE_B.  */
-  hash_set<const region2 *> base_regions;
+  hash_set<const region *> base_regions;
   for (cluster_map_t::iterator iter_a = store_a->m_cluster_map.begin ();
        iter_a != store_a->m_cluster_map.end (); ++iter_a)
     {
-      const region2 *base_reg_a = (*iter_a).first;
+      const region *base_reg_a = (*iter_a).first;
       base_regions.add (base_reg_a);
     }
   for (cluster_map_t::iterator iter_b = store_b->m_cluster_map.begin ();
        iter_b != store_b->m_cluster_map.end (); ++iter_b)
     {
-      const region2 *base_reg_b = (*iter_b).first;
+      const region *base_reg_b = (*iter_b).first;
       base_regions.add (base_reg_b);
     }
 
-  for (hash_set<const region2 *>::iterator iter = base_regions.begin ();
+  for (hash_set<const region *>::iterator iter = base_regions.begin ();
        iter != base_regions.end (); ++iter)
     {
-      const region2 *base_reg = *iter;
-      const binding_cluster2 *cluster_a = store_a->get_cluster (base_reg);
-      const binding_cluster2 *cluster_b = store_b->get_cluster (base_reg);
+      const region *base_reg = *iter;
+      const binding_cluster *cluster_a = store_a->get_cluster (base_reg);
+      const binding_cluster *cluster_b = store_b->get_cluster (base_reg);
       /* At least one of cluster_a and cluster_b must be non-NULL.  */
-      binding_cluster2 *out_cluster
+      binding_cluster *out_cluster
 	= out_store->get_or_create_cluster (base_reg);
-      if (!binding_cluster2::can_merge_p (cluster_a, cluster_b,
-					  out_cluster, mgr, merger))
+      if (!binding_cluster::can_merge_p (cluster_a, cluster_b,
+					 out_cluster, mgr, merger))
 	return false;
     }
   return true;
@@ -1696,12 +1696,12 @@ store::can_merge_p (const store *store_a, const store *store_b,
    isn't reachable from args of those calls.  */
 
 void
-store::mark_as_escaped (const region2 *base_reg)
+store::mark_as_escaped (const region *base_reg)
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
 
-  binding_cluster2 *cluster = get_or_create_cluster (base_reg);
+  binding_cluster *cluster = get_or_create_cluster (base_reg);
   cluster->mark_as_escaped ();
   /* FIXME: but don't bother marking every global as escaped; instead,
      m_called_unknown_fn is set on these when on unknown fncalls,
@@ -1726,12 +1726,12 @@ store::on_unknown_fncall (const gcall *call, store_manager *mgr)
    has escaped to code outside of the TU being analyzed.  */
 
 bool
-store::escaped_p (const region2 *base_reg) const
+store::escaped_p (const region *base_reg) const
 {
   gcc_assert (base_reg);
   gcc_assert (base_reg->get_base_region () == base_reg);
 
-  if (binding_cluster2 **cluster_slot
+  if (binding_cluster **cluster_slot
       = const_cast <cluster_map_t &>(m_cluster_map).get (base_reg))
     return (*cluster_slot)->escaped_p ();
   return false;
@@ -1740,9 +1740,9 @@ store::escaped_p (const region2 *base_reg) const
 /* FIXME.  */
 
 void
-store::get_representative_path_vars (const region_model2 *model,
-				     hash_set <const svalue2 *> *visited,
-				     const svalue2 *sval,
+store::get_representative_path_vars (const region_model *model,
+				     hash_set <const svalue *> *visited,
+				     const svalue *sval,
 				     auto_vec<path_var> *out_pvs) const
 {
   gcc_assert (sval);
@@ -1751,15 +1751,15 @@ store::get_representative_path_vars (const region_model2 *model,
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
        iter != m_cluster_map.end (); ++iter)
     {
-      const region2 *base_reg = (*iter).first;
-      binding_cluster2 *cluster = (*iter).second;
+      const region *base_reg = (*iter).first;
+      binding_cluster *cluster = (*iter).second;
       cluster->get_representative_path_vars (model, visited, base_reg, sval,
 					     out_pvs);
     }
 
-  if (const initial_svalue2 *init_sval = sval->dyn_cast_initial_svalue2 ())
+  if (const initial_svalue *init_sval = sval->dyn_cast_initial_svalue ())
     {
-      const region2 *reg = init_sval->get_region ();
+      const region *reg = init_sval->get_region ();
       if (path_var pv = model->get_representative_path_var (reg,
 							    visited))
 	out_pvs->safe_push (pv);
@@ -1769,29 +1769,29 @@ store::get_representative_path_vars (const region_model2 *model,
 /* FIXME.  */
 
 void
-store::remove_overlapping_bindings (store_manager *mgr, const region2 *reg)
+store::remove_overlapping_bindings (store_manager *mgr, const region *reg)
 {
-  const region2 *base_reg = reg->get_base_region ();
+  const region *base_reg = reg->get_base_region ();
   if (reg == base_reg && !escaped_p (base_reg))
     {
       /* Remove whole cluster (if any).  */
       m_cluster_map.remove (base_reg);
       return;
     }
-  if (binding_cluster2 **cluster_slot = m_cluster_map.get (base_reg))
+  if (binding_cluster **cluster_slot = m_cluster_map.get (base_reg))
     (*cluster_slot)->remove_overlapping_bindings (mgr, reg);
 }
 
 /* FIXME.  */
 
-struct region2_finder : public visitor
+struct region_finder : public visitor
 {
-  void visit_region (const region2 *reg) FINAL OVERRIDE
+  void visit_region (const region *reg) FINAL OVERRIDE
   {
     m_regs.add (reg);
   }
 
-  hash_set<const region2 *> m_regs;
+  hash_set<const region *> m_regs;
 };
 
 /* FIXME.  */
@@ -1807,25 +1807,25 @@ store::canonicalize (store_manager *mgr)
      cluster, to avoid unbounded state chains involving these.  */
 
   /* Find regions that are referenced by bound values in the store.  */
-  region2_finder s;
+  region_finder s;
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
        iter != m_cluster_map.end (); ++iter)
     {
-      binding_cluster2 *cluster = (*iter).second;
-      for (binding_cluster2::iterator_t bind_iter = cluster->m_map.begin ();
+      binding_cluster *cluster = (*iter).second;
+      for (binding_cluster::iterator_t bind_iter = cluster->m_map.begin ();
 	   bind_iter != cluster->m_map.end (); ++bind_iter)
 	(*bind_iter).second->accept (&s);
     }
 
   /* Locate heap-allocated regions that have empty bindings that weren't
      found above.  */
-  hash_set<const region2 *> purgeable_regions;
+  hash_set<const region *> purgeable_regions;
   for (cluster_map_t::iterator iter = m_cluster_map.begin ();
        iter != m_cluster_map.end (); ++iter)
     {
-      const region2 *base_reg = (*iter).first;
-      binding_cluster2 *cluster = (*iter).second;
-      if (base_reg->get_kind () == region2::RK_HEAP_ALLOCATED)
+      const region *base_reg = (*iter).first;
+      binding_cluster *cluster = (*iter).second;
+      if (base_reg->get_kind () == region::RK_HEAP_ALLOCATED)
 	{
 	  if (cluster->empty_p ())
 	    if (!s.m_regs.contains (base_reg))
@@ -1833,28 +1833,28 @@ store::canonicalize (store_manager *mgr)
 
 	  /* Also cover the UNKNOWN case.  */
 	  // TODO: maybe we should canonicalize these to be empty first, instead
-	  if (const svalue2 *sval = cluster->maybe_get_simple_value (mgr))
-	    if (sval->get_kind () == svalue2::SK_UNKNOWN)
+	  if (const svalue *sval = cluster->maybe_get_simple_value (mgr))
+	    if (sval->get_kind () == svalue::SK_UNKNOWN)
 	      if (!s.m_regs.contains (base_reg))
 		purgeable_regions.add (base_reg);
 	}
     }
 
   /* Purge them.  */
-  for (hash_set<const region2 *>::iterator iter = purgeable_regions.begin ();
+  for (hash_set<const region *>::iterator iter = purgeable_regions.begin ();
        iter != purgeable_regions.end (); ++iter)
     {
-      const region2 *base_reg = *iter;
+      const region *base_reg = *iter;
       purge_cluster (base_reg);
     }
 }
 
-/* Subroutine for use by exploded_path::feasible2_p.
+/* Subroutine for use by exploded_path::feasible_p.
 
    We need to deal with state differences between:
    (a) when the exploded_graph is being initially constructed and
    (b) when replaying the state changes along a specific path in
-   in exploded_path::feasible2_p.
+   in exploded_path::feasible_p.
 
    In (a), state merging happens, so when exploring a loop
      for (i = 0; i < 1024; i++)
@@ -1876,25 +1876,25 @@ store::canonicalize (store_manager *mgr)
 
 void
 store::loop_replay_hack (const store *other_store,
-			 region_model2_manager *mgr)
+			 region_model_manager *mgr)
 {
   gcc_assert (other_store);
   for (cluster_map_t::iterator iter = other_store->m_cluster_map.begin ();
        iter != other_store->m_cluster_map.end (); ++iter)
     {
-      const region2 *base_reg = (*iter).first;
-      binding_cluster2 *cluster = (*iter).second;
-      for (binding_cluster2::iterator_t bind_iter = cluster->m_map.begin ();
+      const region *base_reg = (*iter).first;
+      binding_cluster *cluster = (*iter).second;
+      for (binding_cluster::iterator_t bind_iter = cluster->m_map.begin ();
 	   bind_iter != cluster->m_map.end (); ++bind_iter)
 	{
 	  const binding_key *key = (*bind_iter).first;
-	  const svalue2 *sval = (*bind_iter).second;
-	  if (sval->get_kind () == svalue2::SK_WIDENING)
+	  const svalue *sval = (*bind_iter).second;
+	  if (sval->get_kind () == svalue::SK_WIDENING)
 	    {
-	      binding_cluster2 *this_cluster
+	      binding_cluster *this_cluster
 		= get_or_create_cluster (base_reg);
-	      const svalue2 *unknown
-		= mgr->get_or_create_unknown_svalue2 (sval->get_type ());
+	      const svalue *unknown
+		= mgr->get_or_create_unknown_svalue (sval->get_type ());
 	      this_cluster->bind_key (key, unknown);
 	    }
 	}
diff --git a/gcc/analyzer/store.h b/gcc/analyzer/store.h
index 0f329b61510..b0685d49ce7 100644
--- a/gcc/analyzer/store.h
+++ b/gcc/analyzer/store.h
@@ -154,7 +154,7 @@ public:
   virtual bool concrete_p () const = 0;
   bool symbolic_p () const { return !concrete_p (); }
 
-  static const binding_key *make (store_manager *mgr, const region2 *r,
+  static const binding_key *make (store_manager *mgr, const region *r,
 				   enum binding_kind kind);
 
   virtual void dump_to_pp (pretty_printer *pp, bool simple) const;
@@ -241,7 +241,7 @@ private:
 class symbolic_binding : public binding_key
 {
 public:
-  symbolic_binding (const region2 *region, enum binding_kind kind)
+  symbolic_binding (const region *region, enum binding_kind kind)
   : binding_key (kind),
     m_region (region)
   {}
@@ -261,19 +261,19 @@ public:
 
   void dump_to_pp (pretty_printer *pp, bool simple) const FINAL OVERRIDE;
 
-  const region2 *get_region () const { return m_region; }
+  const region *get_region () const { return m_region; }
 
 private:
-  const region2 *m_region;
+  const region *m_region;
 };
 
 /* FIXME.
-   For use by binding_cluster2 and compound_svalue2.  */
+   For use by binding_cluster and compound_svalue.  */
 
 class binding_map
 {
 public:
-  typedef hash_map <const binding_key *, const svalue2 *> map_t;
+  typedef hash_map <const binding_key *, const svalue *> map_t;
   typedef map_t::iterator iterator_t;
 
   binding_map () : m_map () {}
@@ -286,15 +286,15 @@ public:
     return !(*this == other);
   }
 
-  const svalue2 *get (const binding_key *key) const
+  const svalue *get (const binding_key *key) const
   {
-    const svalue2 **slot = const_cast<map_t &> (m_map).get (key);
+    const svalue **slot = const_cast<map_t &> (m_map).get (key);
     if (slot)
       return *slot;
     else
       return NULL;
   }
-  bool put (const binding_key *k, const svalue2 *v)
+  bool put (const binding_key *k, const svalue *v)
   {
     gcc_assert (v);
     return m_map.put (k, v);
@@ -314,32 +314,32 @@ private:
   map_t m_map;
 };
 
-/* Concept: BindingVisitor, for use by binding_cluster2::for_each_binding
+/* Concept: BindingVisitor, for use by binding_cluster::for_each_binding
    and store::for_each_binding.
 
    Should implement:
-     void on_binding (const binding_key *key, const svalue2 *&sval);
+     void on_binding (const binding_key *key, const svalue *&sval);
 */
 
 /* All of the bindings within a store for regions that share the same
    base region.  */
 
-class binding_cluster2
+class binding_cluster
 {
 public:
   friend class store; // FIXME
 
-  typedef hash_map <const binding_key *, const svalue2 *> map_t;
+  typedef hash_map <const binding_key *, const svalue *> map_t;
   typedef map_t::iterator iterator_t;
 
-  binding_cluster2 (const region2 *base_region)
+  binding_cluster (const region *base_region)
   : m_base_region (base_region), m_map (),
     m_escaped (false), m_touched (false) {}
-  binding_cluster2 (const binding_cluster2 &other);
-  binding_cluster2& operator=(const binding_cluster2 &other);
+  binding_cluster (const binding_cluster &other);
+  binding_cluster& operator=(const binding_cluster &other);
 
-  bool operator== (const binding_cluster2 &other) const;
-  bool operator!= (const binding_cluster2 &other) const
+  bool operator== (const binding_cluster &other) const;
+  bool operator!= (const binding_cluster &other) const
   {
     return !(*this == other);
   }
@@ -349,29 +349,29 @@ public:
   void dump_to_pp (pretty_printer *pp, bool simple, bool multiline) const;
   void dump (bool simple) const;
 
-  void bind (store_manager *mgr, const region2 *, const svalue2 *,
+  void bind (store_manager *mgr, const region *, const svalue *,
 	     binding_kind kind);
 
-  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);
+  void clobber_region (store_manager *mgr, const region *reg);
+  void purge_region (store_manager *mgr, const region *reg);
+  void zero_fill_region (store_manager *mgr, const region *reg);
+  void mark_region_as_unknown (store_manager *mgr, const region *reg);
 
-  const svalue2 *get_binding (store_manager *mgr, const region2 *reg,
+  const svalue *get_binding (store_manager *mgr, const region *reg,
 			      binding_kind kind) const;
-  const svalue2 *get_binding_recursive (store_manager *mgr,
-					const region2 *reg,
+  const svalue *get_binding_recursive (store_manager *mgr,
+					const region *reg,
 					enum binding_kind kind) const;
-  const svalue2 *get_any_binding (store_manager *mgr,
-				  const region2 *reg) const;
-  const svalue2 *maybe_get_compound_binding (store_manager *mgr,
-					     const region2 *reg) const;
+  const svalue *get_any_binding (store_manager *mgr,
+				  const region *reg) const;
+  const svalue *maybe_get_compound_binding (store_manager *mgr,
+					     const region *reg) const;
 
-  void remove_overlapping_bindings (store_manager *mgr, const region2 *reg);
+  void remove_overlapping_bindings (store_manager *mgr, const region *reg);
 
 #if 1
   template <typename T>
-  void for_each_value (void (*cb) (const svalue2 *sval, T user_data),
+  void for_each_value (void (*cb) (const svalue *sval, T user_data),
 		       T user_data)
   {
     for (map_t::iterator iter = m_map.begin (); iter != m_map.end (); ++iter)
@@ -379,12 +379,12 @@ public:
   }
 #endif
 
-  static bool can_merge_p (const binding_cluster2 *cluster_a,
-			   const binding_cluster2 *cluster_b,
-			   binding_cluster2 *out_cluster,
+  static bool can_merge_p (const binding_cluster *cluster_a,
+			   const binding_cluster *cluster_b,
+			   binding_cluster *out_cluster,
 			   store_manager *mgr,
-			   model2_merger *merger);
-  void make_unknown_relative_to (const binding_cluster2 *other_cluster,
+			   model_merger *merger);
+  void make_unknown_relative_to (const binding_cluster *other_cluster,
 				 store_manager *mgr);
 
   void mark_as_escaped ();
@@ -396,13 +396,13 @@ public:
   bool redundant_p () const;
   bool empty_p () const { return m_map.elements () == 0; }
 
-  void get_representative_path_vars (const region_model2 *model,
-				     hash_set <const svalue2 *> *visited,
-				     const region2 *base_reg,
-				     const svalue2 *sval,
+  void get_representative_path_vars (const region_model *model,
+				     hash_set <const svalue *> *visited,
+				     const region *base_reg,
+				     const svalue *sval,
 				     auto_vec<path_var> *out_pvs) const;
 
-  const svalue2 *maybe_get_simple_value (store_manager *mgr) const;
+  const svalue *maybe_get_simple_value (store_manager *mgr) const;
 
   template <typename BindingVisitor>
   void for_each_binding (BindingVisitor &v)
@@ -410,7 +410,7 @@ public:
     for (map_t::iterator iter = m_map.begin (); iter != m_map.end (); ++iter)
       {
 	const binding_key *key = (*iter).first;
-	const svalue2 *&sval = (*iter).second;
+	const svalue *&sval = (*iter).second;
 	v.on_binding (key, sval);
       }
   }
@@ -419,15 +419,15 @@ public:
   iterator_t end () const { return m_map.end (); }
 
 private:
-  const svalue2 *get_any_value (const binding_key *key) const;
-  void get_overlapping_bindings (store_manager *mgr, const region2 *reg,
+  const svalue *get_any_value (const binding_key *key) const;
+  void get_overlapping_bindings (store_manager *mgr, const region *reg,
 				 auto_vec<const binding_key *> *out);
   void bind_compound_sval (store_manager *mgr,
-			   const region2 *reg,
-			   const compound_svalue2 *compound_sval);
-  void bind_key (const binding_key *key, const svalue2 *sval);
+			   const region *reg,
+			   const compound_svalue *compound_sval);
+  void bind_key (const binding_key *key, const svalue *sval);
 
-  const region2 *m_base_region;
+  const region *m_base_region;
 
   binding_map m_map;
 
@@ -443,7 +443,7 @@ private:
 
   /* Has this cluster been written to via a symbolic binding?
      If so, then we don't know anything about unbound subregions,
-     so we can't use initial_svalue2, treat them as uninitialized, or
+     so we can't use initial_svalue, treat them as uninitialized, or
      inherit values from a parent region.  */
   bool m_touched;
 
@@ -457,7 +457,7 @@ private:
 class store
 {
 public:
-  typedef hash_map <const region2 *, binding_cluster2 *> cluster_map_t;
+  typedef hash_map <const region *, binding_cluster *> cluster_map_t;
 
   store ();
   store (const store &other);
@@ -476,26 +476,26 @@ public:
   void dump (bool simple) const;
   void summarize_to_pp (pretty_printer *pp, bool simple) 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;
+  const svalue *get_direct_binding (store_manager *mgr, const region *reg);
+  const svalue *get_default_binding (store_manager *mgr, const region *reg);
+  const svalue *get_any_binding (store_manager *mgr, const region *reg) const;
 
   bool called_unknown_fn_p () const { return m_called_unknown_fn; }
 
-  void set_value (store_manager *mgr, const region2 *lhs_reg,
-		  const svalue2 *rhs_sval, enum binding_kind kind);
-  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);
+  void set_value (store_manager *mgr, const region *lhs_reg,
+		  const svalue *rhs_sval, enum binding_kind kind);
+  void clobber_region (store_manager *mgr, const region *reg);
+  void purge_region (store_manager *mgr, const region *reg);
+  void zero_fill_region (store_manager *mgr, const region *reg);
+  void mark_region_as_unknown (store_manager *mgr, const region *reg);
 
-  const binding_cluster2 *get_cluster (const region2 *base_reg) const;
-  binding_cluster2 *get_cluster (const region2 *base_reg);
-  binding_cluster2 *get_or_create_cluster (const region2 *base_reg);
-  void purge_cluster (const region2 *base_reg);
+  const binding_cluster *get_cluster (const region *base_reg) const;
+  binding_cluster *get_cluster (const region *base_reg);
+  binding_cluster *get_or_create_cluster (const region *base_reg);
+  void purge_cluster (const region *base_reg);
 
   template <typename T>
-  void for_each_cluster (void (*cb) (const region2 *base_reg, T user_data),
+  void for_each_cluster (void (*cb) (const region *base_reg, T user_data),
 			 T user_data) const
   {
     for (cluster_map_t::iterator iter = m_cluster_map.begin ();
@@ -505,22 +505,22 @@ public:
 
   static bool can_merge_p (const store *store_a, const store *store_b,
 			   store *out_store, store_manager *mgr,
-			   model2_merger *merger);
+			   model_merger *merger);
 
-  void mark_as_escaped (const region2 *base_reg);
+  void mark_as_escaped (const region *base_reg);
   void on_unknown_fncall (const gcall *call, store_manager *mgr);
-  bool escaped_p (const region2 *reg) const;
+  bool escaped_p (const region *reg) const;
 
-  void get_representative_path_vars (const region_model2 *model,
-				     hash_set <const svalue2 *> *visited,
-				     const svalue2 *sval,
+  void get_representative_path_vars (const region_model *model,
+				     hash_set <const svalue *> *visited,
+				     const svalue *sval,
 				     auto_vec<path_var> *out_pvs) const;
 
   cluster_map_t::iterator begin () const { return m_cluster_map.begin (); }
   cluster_map_t::iterator end () const { return m_cluster_map.end (); }
 
-  tristate eval_alias (const region2 *base_reg_a,
-		       const region2 *base_reg_b);
+  tristate eval_alias (const region *base_reg_a,
+		       const region *base_reg_b);
 
   template <typename BindingVisitor>
   void for_each_binding (BindingVisitor &v)
@@ -532,10 +532,10 @@ public:
 
   void canonicalize (store_manager *mgr);
   void loop_replay_hack (const store *other_store,
-			 region_model2_manager *mgr);
+			 region_model_manager *mgr);
 
 private:
-  void remove_overlapping_bindings (store_manager *mgr, const region2 *reg);
+  void remove_overlapping_bindings (store_manager *mgr, const region *reg);
 
   cluster_map_t m_cluster_map; // TODO: deep copy of this!
 
@@ -551,7 +551,7 @@ private:
 class store_manager
 {
 public:
-  store_manager (region_model2_manager *mgr) : m_mgr (mgr) {}
+  store_manager (region_model_manager *mgr) : m_mgr (mgr) {}
 
   /* binding consolidation.  */
   const concrete_binding *
@@ -559,10 +559,10 @@ public:
 			bit_offset_t size_in_bits,
 			enum binding_kind kind);
   const symbolic_binding *
-  get_symbolic_binding (const region2 *region,
+  get_symbolic_binding (const region *region,
 			enum binding_kind kind);
 
-  region_model2_manager *get_svalue2_manager () const
+  region_model_manager *get_svalue_manager () const
   {
     return m_mgr;
   }
@@ -570,7 +570,7 @@ public:
   void log_stats (logger *logger, bool show_objs) const;
 
 private:
-  region_model2_manager *m_mgr;
+  region_model_manager *m_mgr;
   uniq_manager<concrete_binding> m_concrete_binding_key_mgr;
   uniq_manager<symbolic_binding> m_symbolic_binding_key_mgr;
 };
-- 
2.26.2

