[committed] analyzer: consolidate call_string instances

diff --git a/gcc/analyzer/call-string.cc b/gcc/analyzer/call-string.cc
index 2ccd3ccd6fb..a09f569d9d1 100644
--- a/gcc/analyzer/call-string.cc
+++ b/gcc/analyzer/call-string.cc
@@ -25,7 +25,6 @@  along with GCC; see the file COPYING3.  If not see
 #include "tree.h"
 #include "options.h"
 #include "json.h"
-#include "analyzer/call-string.h"
 #include "ordered-hash-map.h"
 #include "options.h"
 #include "cgraph.h"
@@ -35,6 +34,9 @@  along with GCC; see the file COPYING3.  If not see
 #include "gimple.h"
 #include "gimple-iterator.h"
 #include "digraph.h"
+#include "analyzer/analyzer.h"
+#include "analyzer/analyzer-logging.h"
+#include "analyzer/call-string.h"
 #include "analyzer/supergraph.h"
 
 #if ENABLE_ANALYZER
@@ -74,45 +76,6 @@  call_string::element_t::get_callee_function () const
   return m_callee->get_function ();
 }
 
-/* call_string's copy ctor.  */
-
-call_string::call_string (const call_string &other)
-: m_elements (other.m_elements.length ())
-{
-  for (const call_string::element_t &e : other.m_elements)
-    m_elements.quick_push (e);
-}
-
-/* call_string's assignment operator.  */
-
-call_string&
-call_string::operator= (const call_string &other)
-{
-  // would be much simpler if we could rely on vec<> assignment op
-  m_elements.truncate (0);
-  m_elements.reserve (other.m_elements.length (), true);
-  call_string::element_t *e;
-  int i;
-  FOR_EACH_VEC_ELT (other.m_elements, i, e)
-    m_elements.quick_push (*e);
-  return *this;
-}
-
-/* call_string's equality operator.  */
-
-bool
-call_string::operator== (const call_string &other) const
-{
-  if (m_elements.length () != other.m_elements.length ())
-    return false;
-  call_string::element_t *e;
-  int i;
-  FOR_EACH_VEC_ELT (m_elements, i, e)
-    if (*e != other.m_elements[i])
-      return false;
-  return true;
-}
-
 /* Print this to PP.  */
 
 void
@@ -160,43 +123,34 @@  call_string::to_json () const
   return arr;
 }
 
-/* Generate a hash value for this call_string.  */
+/* Get or create the call_string resulting from pushing the return
+   superedge for CALL_SEDGE onto the end of this call_string.  */
 
-hashval_t
-call_string::hash () const
-{
-  inchash::hash hstate;
-  for (const call_string::element_t &e : m_elements)
-    hstate.add_ptr (e.m_caller);
-  return hstate.end ();
-}
-
-/* Push the return superedge for CALL_SEDGE onto the end of this
-   call_string.  */
-
-void
+const call_string *
 call_string::push_call (const supergraph &sg,
-			const call_superedge *call_sedge)
+			const call_superedge *call_sedge) const
 {
   gcc_assert (call_sedge);
   const return_superedge *return_sedge = call_sedge->get_edge_for_return (sg);
   gcc_assert (return_sedge);
-  call_string::element_t e (return_sedge->m_dest, return_sedge->m_src);
-  m_elements.safe_push (e);
+  return push_call (return_sedge->m_dest, return_sedge->m_src);
 }
 
-void
+/* Get or create the call_string resulting from pushing the call
+   (caller, callee) onto the end of this call_string.  */
+
+const call_string *
 call_string::push_call (const supernode *caller,
-			const supernode *callee)
+			const supernode *callee) const
 {
   call_string::element_t e (caller, callee);
-  m_elements.safe_push (e);
-}
 
-call_string::element_t
-call_string::pop ()
-{
-  return m_elements.pop();
+  if (const call_string **slot = m_children.get (e))
+    return *slot;
+
+  call_string *result = new call_string (*this, e);
+  m_children.put (e, result);
+  return result;
 }
 
 /* Count the number of times the top-most call site appears in the
@@ -260,6 +214,16 @@  call_string::cmp (const call_string &a,
     }
 }
 
+/* Comparator for use by vec<const call_string *>::qsort.  */
+
+int
+call_string::cmp_ptr_ptr (const void *pa, const void *pb)
+{
+  const call_string *cs_a = *static_cast <const call_string * const *> (pa);
+  const call_string *cs_b = *static_cast <const call_string * const *> (pb);
+  return cmp (*cs_a, *cs_b);
+}
+
 /* Return the pointer to callee of the topmost call in the stack,
    or NULL if stack is empty.  */
 const supernode *
@@ -290,6 +254,8 @@  call_string::validate () const
   return;
 #endif
 
+  gcc_assert (m_parent || m_elements.length () == 0);
+
   /* Each entry's "caller" should be the "callee" of the previous entry.  */
   call_string::element_t *e;
   int i;
@@ -299,4 +265,68 @@  call_string::validate () const
 		  m_elements[i - 1].get_callee_function ());
 }
 
+/* ctor for the root/empty call_string.  */
+
+call_string::call_string ()
+: m_parent (NULL), m_elements ()
+{
+}
+
+/* ctor for a child call_string.  */
+
+call_string::call_string (const call_string &parent, const element_t &to_push)
+: m_parent (&parent),
+  m_elements (parent.m_elements.length () + 1)
+{
+  m_elements.splice (parent.m_elements);
+  m_elements.quick_push (to_push);
+}
+
+/* dtor for call_string: recursively delete children.  */
+
+call_string::~call_string ()
+{
+  for (auto child_iter : m_children)
+    delete child_iter.second;
+}
+
+/* Log this call_string and all its descendents recursively to LOGGER,
+   using indentation and elision to highlight the hierarchy.  */
+
+void
+call_string::recursive_log (logger *logger) const
+{
+  logger->start_log_line ();
+  pretty_printer *pp = logger->get_printer ();
+  for (unsigned i = 0; i < length (); i++)
+    pp_string (pp, "  ");
+  if (length () > 0)
+    {
+      pp_string (pp, "[");
+      /* Elide all but the final element, since they are shared with
+	 the parent call_string.  */
+      for (unsigned i = 0; i < length (); i++)
+	pp_string (pp, "..., ");
+      /* Log the final element in detail.  */
+      const element_t *e = &m_elements[m_elements.length () - 1];
+      pp_printf (pp, "(SN: %i -> SN: %i in %s)]",
+		 e->m_callee->m_index, e->m_caller->m_index,
+		 function_name (e->m_caller->m_fun));
+    }
+  else
+    pp_string (pp, "[]");
+  logger->end_log_line ();
+
+  /* Recurse into children.  */
+  {
+    auto_vec<const call_string *> children (m_children.elements ());
+    for (auto iter : m_children)
+      children.safe_push (iter.second);
+    children.qsort (call_string::cmp_ptr_ptr);
+
+    for (auto iter : children)
+      iter->recursive_log (logger);
+  }
+}
+
 #endif /* #if ENABLE_ANALYZER */
diff --git a/gcc/analyzer/call-string.h b/gcc/analyzer/call-string.h
index 87d04a1c4cc..c3cea903277 100644
--- a/gcc/analyzer/call-string.h
+++ b/gcc/analyzer/call-string.h
@@ -36,8 +36,13 @@  class return_superedge;
    i.e. that we return to the same callsite that called us.
 
    The class stores returning calls ( which may be represented by a
-   returning superedge ). We do so because this is what we need to compare 
-   against.  */
+   returning superedge ). We do so because this is what we need to compare
+   against.
+
+   Instances of call_string are consolidated by the region_model_manager,
+   which effectively owns them: it owns the root/empty call_string, and each
+   call_string instance tracks its children, lazily creating them on demand,
+   so that the call_string instances form a tree-like hierarchy in memory.  */
 
 class call_string
 {
@@ -60,38 +65,31 @@  public:
     /* Accessors */
     function *get_caller_function () const;
     function *get_callee_function () const;
-    
+
     const supernode *m_caller;
     const supernode *m_callee;
   };
 
-  call_string () : m_elements () {}
-  call_string (const call_string &other);
-  call_string& operator= (const call_string &other);
-
-  bool operator== (const call_string &other) const;
-
   void print (pretty_printer *pp) const;
 
   json::value *to_json () const;
 
-  hashval_t hash () const;
-
   bool empty_p () const { return m_elements.is_empty (); }
 
-  void push_call (const supergraph &sg,
-		  const call_superedge *sedge);
-
-  void push_call (const supernode *src, 
-    const supernode *dest);
+  const call_string *push_call (const supergraph &sg,
+				const call_superedge *sedge) const;
 
-  element_t pop ();
+  const call_string *push_call (const supernode *src,
+				const supernode *dest) const;
+  const call_string *get_parent () const { return m_parent; }
 
   int calc_recursion_depth () const;
 
   static int cmp (const call_string &a,
 		  const call_string &b);
 
+  static int cmp_ptr_ptr (const void *, const void *);
+
   /* Accessors */
 
   const supernode *get_callee_node () const;
@@ -101,11 +99,69 @@  public:
   {
     return m_elements[idx];
   }
+  const element_t &get_top_of_stack () const
+  {
+    gcc_assert (m_elements.length () > 0);
+    return m_elements[m_elements.length () - 1];
+  }
 
   void validate () const;
 
 private:
+  struct hashmap_traits_t
+  {
+    typedef element_t key_type;
+    typedef const call_string *value_type;
+
+    static const bool maybe_mx = false;
+    static inline hashval_t hash (const key_type &k)
+    {
+      inchash::hash hstate;
+      hstate.add_ptr (k.m_caller);
+      hstate.add_ptr (k.m_callee);
+      return hstate.end ();
+    }
+    static inline bool equal_keys (const key_type &k1, const key_type &k2)
+    {
+      return k1 == k2;
+    }
+    template <typename T> static inline void remove (T &entry)
+    {
+      entry.m_key = element_t (NULL, NULL);
+    }
+    static const bool empty_zero_p = true;
+    template <typename T> static inline bool is_empty (const T &entry)
+    {
+      return entry.m_key.m_caller == NULL;
+    }
+    template <typename T> static inline bool is_deleted (const T &entry)
+    {
+      return entry.m_key.m_caller == reinterpret_cast<const supernode *> (1);
+    }
+    template <typename T> static inline void mark_empty (T &entry)
+    {
+      entry.m_key = element_t (NULL, NULL);
+      entry.m_value = NULL;
+    }
+    template <typename T> static inline void mark_deleted (T &entry)
+    {
+      entry.m_key.m_caller = reinterpret_cast<const supernode *> (1);
+    }
+  };
+
+  friend class region_model_manager;
+
+  DISABLE_COPY_AND_ASSIGN (call_string);
+
+  call_string ();
+  call_string (const call_string &parent, const element_t &to_push);
+  ~call_string ();
+
+  void recursive_log (logger *logger) const;
+
+  const call_string *m_parent;
   auto_vec<element_t> m_elements;
+  mutable hash_map<element_t, const call_string *, hashmap_traits_t> m_children;
 };
 
 } // namespace ana
diff --git a/gcc/analyzer/constraint-manager.cc b/gcc/analyzer/constraint-manager.cc
index 02e8ce9a457..4133a134778 100644
--- a/gcc/analyzer/constraint-manager.cc
+++ b/gcc/analyzer/constraint-manager.cc
@@ -3923,10 +3923,10 @@  test_equality ()
 static void
 test_many_constants ()
 {
-  program_point point (program_point::origin ());
+  region_model_manager mgr;
+  program_point point (program_point::origin (mgr));
   tree a = build_global_decl ("a", integer_type_node);
 
-  region_model_manager mgr;
   region_model model (&mgr);
   auto_vec<tree> constants;
   for (int i = 0; i < 20; i++)
diff --git a/gcc/analyzer/engine.cc b/gcc/analyzer/engine.cc
index 51dfe298230..0674c8ba3b6 100644
--- a/gcc/analyzer/engine.cc
+++ b/gcc/analyzer/engine.cc
@@ -2374,8 +2374,9 @@  exploded_graph::exploded_graph (const supergraph &sg, logger *logger,
   m_functionless_stats (m_sg.num_nodes ()),
   m_PK_AFTER_SUPERNODE_per_snode (m_sg.num_nodes ())
 {
-  m_origin = get_or_create_node (program_point::origin (),
-				 program_state (ext_state), NULL);
+  m_origin = get_or_create_node
+    (program_point::origin (*ext_state.get_model_manager ()),
+     program_state (ext_state), NULL);
   for (int i = 0; i < m_sg.num_nodes (); i++)
     m_PK_AFTER_SUPERNODE_per_snode.quick_push (i);
 }
@@ -2526,7 +2527,9 @@  exploded_graph::add_function_entry (function *fun)
       return NULL;
     }
 
-  program_point point = program_point::from_function_entry (m_sg, fun);
+  program_point point
+    = program_point::from_function_entry (*m_ext_state.get_model_manager (),
+					  m_sg, fun);
   program_state state (m_ext_state);
   state.push_frame (m_ext_state, fun);
 
@@ -2979,7 +2982,8 @@  add_tainted_args_callback (exploded_graph *eg, tree field, tree fndecl,
   gcc_assert (fun);
 
   program_point point
-    = program_point::from_function_entry (eg->get_supergraph (), fun);
+    = program_point::from_function_entry (*ext_state.get_model_manager (),
+					  eg->get_supergraph (), fun);
   program_state state (ext_state);
   state.push_frame (ext_state, fun);
 
@@ -3341,7 +3345,7 @@  maybe_process_run_of_before_supernode_enodes (exploded_node *enode)
 
       if (point_2.get_kind () == PK_BEFORE_SUPERNODE
 	  && point_2.get_supernode () == snode
-	  && point_2.get_call_string () == point.get_call_string ())
+	  && &point_2.get_call_string () == &point.get_call_string ())
 	{
 	  enodes.safe_push (enode_2);
 	  m_worklist.take_next ();
@@ -4048,7 +4052,7 @@  exploded_graph::process_node (exploded_node *node)
 	if ((is_an_exit_block && !found_a_superedge)
 	    && (!point.get_call_string ().empty_p ()))
 	  {
-	    const call_string cs = point.get_call_string ();
+	    const call_string &cs = point.get_call_string ();
 	    program_point next_point
 	      = program_point::before_supernode (cs.get_caller_node (),
 						 NULL,
@@ -4736,7 +4740,7 @@  private:
 class function_call_string_cluster : public exploded_cluster
 {
 public:
-  function_call_string_cluster (function *fun, call_string cs)
+  function_call_string_cluster (function *fun, const call_string &cs)
   : m_fun (fun), m_cs (cs) {}
 
   ~function_call_string_cluster ()
@@ -4811,7 +4815,7 @@  public:
 
 private:
   function *m_fun;
-  call_string m_cs;
+  const call_string &m_cs;
   typedef ordered_hash_map<const supernode *, supernode_cluster *> map_t;
   map_t m_map;
 };
@@ -4820,14 +4824,15 @@  private:
 
 struct function_call_string
 {
-  function_call_string (function *fun, call_string cs)
+  function_call_string (function *fun, const call_string *cs)
   : m_fun (fun), m_cs (cs)
   {
     gcc_assert (fun);
+    gcc_assert (cs);
   }
 
   function *m_fun;
-  call_string m_cs;
+  const call_string *m_cs;
 };
 
 } // namespace ana
@@ -4842,7 +4847,8 @@  template <>
 inline hashval_t
 pod_hash_traits<function_call_string>::hash (value_type v)
 {
-  return pointer_hash <function>::hash (v.m_fun) ^ v.m_cs.hash ();
+  return (pointer_hash <function>::hash (v.m_fun)
+	  ^ pointer_hash <const call_string>::hash (v.m_cs));
 }
 
 template <>
@@ -4850,7 +4856,7 @@  inline bool
 pod_hash_traits<function_call_string>::equal (const value_type &existing,
 					      const value_type &candidate)
 {
-  return existing.m_fun == candidate.m_fun && existing.m_cs == candidate.m_cs;
+  return existing.m_fun == candidate.m_fun && &existing.m_cs == &candidate.m_cs;
 }
 template <>
 inline void
@@ -4925,7 +4931,7 @@  public:
       }
 
     const call_string &cs = en->get_point ().get_call_string ();
-    function_call_string key (fun, cs);
+    function_call_string key (fun, &cs);
     function_call_string_cluster **slot = m_map.get (key);
     if (slot)
       (*slot)->add_node (en);
@@ -4939,11 +4945,6 @@  public:
   }
 
 private:
-  /* This can't be an ordered_hash_map, as we can't store vec<call_string>,
-     since it's not a POD; vec<>::quick_push has:
-       *slot = obj;
-     and the slot isn't initialized, so the assignment op dies when cleaning up
-     un-inited *slot (within the truncate call).  */
   typedef hash_map<function_call_string, function_call_string_cluster *> map_t;
   map_t m_map;
 
@@ -5319,7 +5320,7 @@  public:
 	    FOR_EACH_VEC_ELT (args.m_eg->m_nodes, i, enode)
 	      {
 		if (enode->get_point ().get_function () == m_fun
-		    && enode->get_point ().get_call_string () == *cs)
+		    && &enode->get_point ().get_call_string () == cs)
 		  num_enodes++;
 	      }
 	    if (num_enodes > 0)
diff --git a/gcc/analyzer/exploded-graph.h b/gcc/analyzer/exploded-graph.h
index 101f4f9a0a0..0613f558b8b 100644
--- a/gcc/analyzer/exploded-graph.h
+++ b/gcc/analyzer/exploded-graph.h
@@ -599,65 +599,10 @@  struct per_call_string_data
   : m_key (key), m_stats (num_supernodes)
   {}
 
-  const call_string m_key;
+  const call_string &m_key;
   stats m_stats;
 };
 
-/* Traits class for storing per-call_string data within
-   an exploded_graph.  */
-
-struct eg_call_string_hash_map_traits
-{
-  typedef const call_string *key_type;
-  typedef per_call_string_data *value_type;
-  typedef per_call_string_data *compare_type;
-
-  static inline hashval_t hash (const key_type &k)
-  {
-    gcc_assert (k != NULL);
-    gcc_assert (k != reinterpret_cast<key_type> (1));
-    return k->hash ();
-  }
-  static inline bool equal_keys (const key_type &k1, const key_type &k2)
-  {
-    gcc_assert (k1 != NULL);
-    gcc_assert (k2 != NULL);
-    gcc_assert (k1 != reinterpret_cast<key_type> (1));
-    gcc_assert (k2 != reinterpret_cast<key_type> (1));
-    if (k1 && k2)
-      return *k1 == *k2;
-    else
-      /* Otherwise they must both be non-NULL.  */
-      return k1 == k2;
-  }
-  template <typename T>
-  static inline void remove (T &)
-  {
-    /* empty; the nodes are handled elsewhere.  */
-  }
-  template <typename T>
-  static inline void mark_deleted (T &entry)
-  {
-    entry.m_key = reinterpret_cast<key_type> (1);
-  }
-  template <typename T>
-  static inline void mark_empty (T &entry)
-  {
-    entry.m_key = NULL;
-  }
-  template <typename T>
-  static inline bool is_deleted (const T &entry)
-  {
-    return entry.m_key == reinterpret_cast<key_type> (1);
-  }
-  template <typename T>
-  static inline bool is_empty (const T &entry)
-  {
-    return entry.m_key == NULL;
-  }
-  static const bool empty_zero_p = false;
-};
-
 /* Data about a particular function within an exploded_graph.  */
 
 struct per_function_data
@@ -791,8 +736,8 @@  private:
 class exploded_graph : public digraph<eg_traits>
 {
 public:
-  typedef hash_map <const call_string *, per_call_string_data *,
-		    eg_call_string_hash_map_traits> call_string_data_map_t;
+  typedef hash_map <const call_string *,
+		    per_call_string_data *> call_string_data_map_t;
 
   exploded_graph (const supergraph &sg, logger *logger,
 		  const extrinsic_state &ext_state,
diff --git a/gcc/analyzer/program-point.cc b/gcc/analyzer/program-point.cc
index 8fa7066fea5..6c296d5ddc8 100644
--- a/gcc/analyzer/program-point.cc
+++ b/gcc/analyzer/program-point.cc
@@ -25,7 +25,6 @@  along with GCC; see the file COPYING3.  If not see
 #include "gimple-pretty-print.h"
 #include "gcc-rich-location.h"
 #include "json.h"
-#include "analyzer/call-string.h"
 #include "ordered-hash-map.h"
 #include "options.h"
 #include "cgraph.h"
@@ -37,6 +36,7 @@  along with GCC; see the file COPYING3.  If not see
 #include "digraph.h"
 #include "analyzer/analyzer.h"
 #include "analyzer/analyzer-logging.h"
+#include "analyzer/call-string.h"
 #include "analyzer/supergraph.h"
 #include "analyzer/program-point.h"
 #include "sbitmap.h"
@@ -290,7 +290,7 @@  void
 program_point::print (pretty_printer *pp, const format &f) const
 {
   pp_string (pp, "callstring: ");
-  m_call_string.print (pp);
+  m_call_string->print (pp);
   f.spacer (pp);
 
   m_function_point.print (pp, f);
@@ -340,7 +340,7 @@  program_point::to_json () const
       break;
     }
 
-  point_obj->set ("call_string", m_call_string.to_json ());
+  point_obj->set ("call_string", m_call_string->to_json ());
 
   return point_obj;
 }
@@ -353,14 +353,15 @@  void
 program_point::push_to_call_stack (const supernode *caller,
 				   const supernode *callee)
 {
-  m_call_string.push_call (callee, caller);
+  m_call_string = m_call_string->push_call (callee, caller);
 }
 
 /* Pop the topmost call from the current callstack.  */
 void
 program_point::pop_from_call_stack ()
 {
-  m_call_string.pop ();
+  m_call_string = m_call_string->get_parent ();
+  gcc_assert (m_call_string);
 }
 
 /* Generate a hash value for this program_point.  */
@@ -370,7 +371,7 @@  program_point::hash () const
 {
   inchash::hash hstate;
   hstate.merge_hash (m_function_point.hash ());
-  hstate.merge_hash (m_call_string.hash ());
+  hstate.add_ptr (m_call_string);
   return hstate.end ();
 }
 
@@ -379,11 +380,11 @@  program_point::hash () const
 function *
 program_point::get_function_at_depth (unsigned depth) const
 {
-  gcc_assert (depth <= m_call_string.length ());
-  if (depth == m_call_string.length ())
+  gcc_assert (depth <= m_call_string->length ());
+  if (depth == m_call_string->length ())
     return m_function_point.get_function ();
   else
-    return m_call_string[depth].get_caller_function ();
+    return get_call_string ()[depth].get_caller_function ();
 }
 
 /* Assert that this object is sane.  */
@@ -396,12 +397,13 @@  program_point::validate () const
   return;
 #endif
 
-  m_call_string.validate ();
+  m_call_string->validate ();
   /* The "callee" of the final entry in the callstring should be the
      function of the m_function_point.  */
-  if (m_call_string.length () > 0)
-    gcc_assert (m_call_string[m_call_string.length () - 1].get_callee_function ()
-		== get_function ());
+  if (m_call_string->length () > 0)
+    gcc_assert
+      ((*m_call_string)[m_call_string->length () - 1].get_callee_function ()
+       == get_function ());
 }
 
 /* Check to see if SUCC is a valid edge to take (ensuring that we have
@@ -444,14 +446,15 @@  program_point::on_edge (exploded_graph &eg,
 	  }
 
 	/* Add the callsite to the call string.  */
-	m_call_string.push_call (eg.get_supergraph (), call_sedge);
+	m_call_string = m_call_string->push_call (eg.get_supergraph (),
+						  call_sedge);
 
 	/* Impose a maximum recursion depth and don't analyze paths
 	   that exceed it further.
 	   This is something of a blunt workaround, but it only
 	   applies to recursion (and mutual recursion), not to
 	   general call stacks.  */
-	if (m_call_string.calc_recursion_depth ()
+	if (m_call_string->calc_recursion_depth ()
 	    > param_analyzer_max_recursion_depth)
 	  {
 	    if (logger)
@@ -465,13 +468,15 @@  program_point::on_edge (exploded_graph &eg,
     case SUPEREDGE_RETURN:
       {
 	/* Require that we return to the call site in the call string.  */
-	if (m_call_string.empty_p ())
+	if (m_call_string->empty_p ())
 	  {
 	    if (logger)
 	      logger->log ("rejecting return edge: empty call string");
 	    return false;
 	  }
-	const call_string::element_t top_of_stack = m_call_string.pop ();
+	const call_string::element_t &top_of_stack
+	  = m_call_string->get_top_of_stack ();
+	m_call_string = m_call_string->get_parent ();
 	call_string::element_t current_call_string_element (succ->m_dest,
 							    succ->m_src);
 	if (top_of_stack != current_call_string_element)
@@ -669,6 +674,25 @@  function_point::get_next () const
     }
 }
 
+/* class program_point.  */
+
+program_point
+program_point::origin (const region_model_manager &mgr)
+{
+  return program_point (function_point (NULL, NULL,
+					0, PK_ORIGIN),
+			mgr.get_empty_call_string ());
+}
+
+program_point
+program_point::from_function_entry (const region_model_manager &mgr,
+				    const supergraph &sg,
+				    function *fun)
+{
+  return program_point (function_point::from_function_entry (sg, fun),
+			mgr.get_empty_call_string ());
+}
+
 /* For those program points for which there is a uniquely-defined
    successor, return it.  */
 
@@ -721,7 +745,6 @@  static void
 test_function_point_ordering ()
 {
   const supernode *snode = NULL;
-  const call_string call_string;
 
   /* Populate an array with various points within the same
      snode, in order.  */
@@ -756,9 +779,11 @@  test_function_point_ordering ()
 static void
 test_program_point_equality ()
 {
+  region_model_manager mgr;
+
   const supernode *snode = NULL;
 
-  const call_string cs;
+  const call_string &cs = mgr.get_empty_call_string ();
 
   program_point a = program_point::before_supernode (snode, NULL,
 						     cs);
diff --git a/gcc/analyzer/program-point.h b/gcc/analyzer/program-point.h
index 6084c9e3004..63f72246f69 100644
--- a/gcc/analyzer/program-point.h
+++ b/gcc/analyzer/program-point.h
@@ -174,7 +174,7 @@  public:
   program_point (const function_point &fn_point,
 		 const call_string &call_string)
   : m_function_point (fn_point),
-    m_call_string (call_string)
+    m_call_string (&call_string)
   {
   }
 
@@ -197,7 +197,7 @@  public:
   /* Accessors.  */
 
   const function_point &get_function_point () const { return m_function_point; }
-  const call_string &get_call_string () const { return m_call_string; }
+  const call_string &get_call_string () const { return *m_call_string; }
 
   const supernode *get_supernode () const
   {
@@ -242,23 +242,14 @@  public:
   {
     if (get_kind () == PK_ORIGIN)
       return 0;
-    return m_call_string.length () + 1;
+    return get_call_string ().length () + 1;
   }
 
   /* Factory functions for making various kinds of program_point.  */
-  static program_point origin ()
-  {
-    return program_point (function_point (NULL, NULL,
-					  0, PK_ORIGIN),
-			  call_string ());
-  }
-
-  static program_point from_function_entry (const supergraph &sg,
-					    function *fun)
-  {
-    return program_point (function_point::from_function_entry (sg, fun),
-			  call_string ());
-  }
+  static program_point origin (const region_model_manager &mgr);
+  static program_point from_function_entry (const region_model_manager &mgr,
+					    const supergraph &sg,
+					    function *fun);
 
   static program_point before_supernode (const supernode *supernode,
 					 const superedge *from_edge,
@@ -288,11 +279,11 @@  public:
 
   static program_point empty ()
   {
-    return program_point (function_point::empty (), call_string ());
+    return program_point (function_point::empty ());
   }
   static program_point deleted ()
   {
-    return program_point (function_point::deleted (), call_string ());
+    return program_point (function_point::deleted ());
   }
 
   bool on_edge (exploded_graph &eg, const superedge *succ);
@@ -306,8 +297,14 @@  public:
   program_point get_next () const;
 
  private:
+  program_point (const function_point &fn_point)
+  : m_function_point (fn_point),
+    m_call_string (NULL)
+  {
+  }
+
   function_point m_function_point;
-  call_string m_call_string;
+  const call_string *m_call_string;
 };
 
 } // namespace ana
diff --git a/gcc/analyzer/program-state.cc b/gcc/analyzer/program-state.cc
index 7ad581c7fbd..295c6aeb185 100644
--- a/gcc/analyzer/program-state.cc
+++ b/gcc/analyzer/program-state.cc
@@ -1668,12 +1668,12 @@  test_program_state_merging ()
      malloc sm-state, pointing to a region on the heap.  */
   tree p = build_global_decl ("p", ptr_type_node);
 
-  program_point point (program_point::origin ());
+  engine eng;
+  region_model_manager *mgr = eng.get_model_manager ();
+  program_point point (program_point::origin (*mgr));
   auto_delete_vec <state_machine> checkers;
   checkers.safe_push (make_malloc_state_machine (NULL));
-  engine eng;
   extrinsic_state ext_state (checkers, &eng);
-  region_model_manager *mgr = eng.get_model_manager ();
 
   program_state s0 (ext_state);
   uncertainty_t uncertainty;
@@ -1736,10 +1736,11 @@  test_program_state_merging ()
 static void
 test_program_state_merging_2 ()
 {
-  program_point point (program_point::origin ());
+  engine eng;
+  region_model_manager *mgr = eng.get_model_manager ();
+  program_point point (program_point::origin (*mgr));
   auto_delete_vec <state_machine> checkers;
   checkers.safe_push (make_signal_state_machine (NULL));
-  engine eng;
   extrinsic_state ext_state (checkers, &eng);
 
   const state_machine::state test_state_0 ("test state 0", 0);
diff --git a/gcc/analyzer/region-model-manager.cc b/gcc/analyzer/region-model-manager.cc
index 3377f15feac..17713b07c30 100644
--- a/gcc/analyzer/region-model-manager.cc
+++ b/gcc/analyzer/region-model-manager.cc
@@ -68,6 +68,7 @@  namespace ana {
 
 region_model_manager::region_model_manager (logger *logger)
 : m_logger (logger),
+  m_empty_call_string (),
   m_next_region_id (0),
   m_root_region (alloc_region_id ()),
   m_stack_region (alloc_region_id (), &m_root_region),
@@ -1748,6 +1749,8 @@  void
 region_model_manager::log_stats (logger *logger, bool show_objs) const
 {
   LOG_SCOPE (logger);
+  logger->log ("call string consolidation");
+  m_empty_call_string.recursive_log (logger);
   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);
diff --git a/gcc/analyzer/region-model.cc b/gcc/analyzer/region-model.cc
index 6b49719d521..5bd5dc720e9 100644
--- a/gcc/analyzer/region-model.cc
+++ b/gcc/analyzer/region-model.cc
@@ -5460,9 +5460,9 @@  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_model_context ctxt;
   region_model_manager *mgr = out_merged_model->get_manager ();
+  program_point point (program_point::origin (*mgr));
+  test_region_model_context ctxt;
   region_model model0 (mgr);
   region_model model1 (mgr);
   if (val_a)
@@ -5511,8 +5511,8 @@  test_state_merging ()
 		       ptr_type_node);
   DECL_CONTEXT (q) = test_fndecl;
 
-  program_point point (program_point::origin ());
   region_model_manager mgr;
+  program_point point (program_point::origin (mgr));
 
   {
     region_model model0 (&mgr);
@@ -5852,7 +5852,7 @@  test_constraint_merging ()
 
   /* They should be mergeable; the merged constraints should
      be: (0 <= x < n).  */
-  program_point point (program_point::origin ());
+  program_point point (program_point::origin (mgr));
   region_model merged (&mgr);
   ASSERT_TRUE (model0.can_merge_with_p (model1, point, &merged));
 
@@ -5873,12 +5873,12 @@  test_constraint_merging ()
 static void
 test_widening_constraints ()
 {
-  program_point point (program_point::origin ());
+  region_model_manager mgr;
+  program_point point (program_point::origin (mgr));
   tree int_0 = build_int_cst (integer_type_node, 0);
   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_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);
@@ -5988,7 +5988,8 @@  test_widening_constraints ()
 static void
 test_iteration_1 ()
 {
-  program_point point (program_point::origin ());
+  region_model_manager mgr;
+  program_point point (program_point::origin (mgr));
 
   tree int_0 = build_int_cst (integer_type_node, 0);
   tree int_1 = build_int_cst (integer_type_node, 1);
@@ -5996,7 +5997,6 @@  test_iteration_1 ()
   tree int_257 = build_int_cst (integer_type_node, 257);
   tree i = build_global_decl ("i", integer_type_node);
 
-  region_model_manager mgr;
   test_region_model_context ctxt;
 
   /* model0: i: 0.  */
diff --git a/gcc/analyzer/region-model.h b/gcc/analyzer/region-model.h
index 1bfa56a8cd2..129aad2945f 100644
--- a/gcc/analyzer/region-model.h
+++ b/gcc/analyzer/region-model.h
@@ -244,6 +244,12 @@  public:
   region_model_manager (logger *logger = NULL);
   ~region_model_manager ();
 
+  /* call_string consolidation.  */
+  const call_string &get_empty_call_string () const
+  {
+    return m_empty_call_string;
+  }
+
   /* svalue consolidation.  */
   const svalue *get_or_create_constant_svalue (tree cst_expr);
   const svalue *get_or_create_int_cst (tree type, poly_int64);
@@ -381,6 +387,8 @@  private:
 
   logger *m_logger;
 
+  const call_string m_empty_call_string;
+
   unsigned m_next_region_id;
   root_region m_root_region;
   stack_region m_stack_region;
diff --git a/gcc/analyzer/sm-signal.cc b/gcc/analyzer/sm-signal.cc
index 1f48a096e5d..b601f450513 100644
--- a/gcc/analyzer/sm-signal.cc
+++ b/gcc/analyzer/sm-signal.cc
@@ -266,11 +266,13 @@  public:
     function *handler_fun = DECL_STRUCT_FUNCTION (m_fndecl);
     if (!handler_fun)
       return;
+    const extrinsic_state &ext_state = eg->get_ext_state ();
     program_point entering_handler
-      = program_point::from_function_entry (eg->get_supergraph (),
+      = program_point::from_function_entry (*ext_state.get_model_manager (),
+					    eg->get_supergraph (),
 					    handler_fun);
 
-    program_state state_entering_handler (eg->get_ext_state ());
+    program_state state_entering_handler (ext_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