[thirdparty/gcc.git] / gcc / hash-map.h

/* A type-safe hash map.
   Copyright (C) 2014-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

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 hash_map_h
#define hash_map_h

/* Class hash_map is a hash-value based container mapping objects of
   KeyId type to those of the Value type.
   Both KeyId and Value may be non-trivial (non-POD) types provided
   a suitabe Traits class.  A few default Traits specializations are
   provided for basic types such as integers, pointers, and std::pair.
   Inserted elements are value-initialized either to zero for POD types
   or by invoking their default ctor.  Removed elements are destroyed
   by invoking their dtor.   On hash_map destruction all elements are
   removed.  Objects of hash_map type are copy-constructible but not
   assignable.  */

const size_t default_hash_map_size = 13;
template<typename KeyId, typename Value,
	 typename Traits /* = simple_hashmap_traits<default_hash_traits<Key>,
			                            Value> */>
class GTY((user)) hash_map
{
  typedef typename Traits::key_type Key;
  struct hash_entry
  {
    Key m_key;
    Value m_value;

    typedef hash_entry value_type;
    typedef Key compare_type;

    static hashval_t hash (const hash_entry &e)
      {
       	return Traits::hash (e.m_key);
      }

    static bool equal (const hash_entry &a, const Key &b)
       	{
	  return Traits::equal_keys (a.m_key, b);
       	}

    static void remove (hash_entry &e) { Traits::remove (e); }

    static void mark_deleted (hash_entry &e) { Traits::mark_deleted (e); }

    static bool is_deleted (const hash_entry &e)
      {
       	return Traits::is_deleted (e);
      }

    static const bool empty_zero_p = Traits::empty_zero_p;
    static void mark_empty (hash_entry &e) { Traits::mark_empty (e); }
    static bool is_empty (const hash_entry &e) { return Traits::is_empty (e); }

    static void ggc_mx (hash_entry &e)
      {
	gt_ggc_mx (e.m_key);
	gt_ggc_mx (e.m_value);
      }

    static void ggc_maybe_mx (hash_entry &e)
      {
	if (Traits::maybe_mx)
	  ggc_mx (e);
      }

    static void pch_nx (hash_entry &e)
      {
	gt_pch_nx (e.m_key);
	gt_pch_nx (e.m_value);
      }

    static void pch_nx (hash_entry &e, gt_pointer_operator op, void *c)
      {
	pch_nx_helper (e.m_key, op, c);
	pch_nx_helper (e.m_value, op, c);
      }

    static int keep_cache_entry (hash_entry &e)
      {
	return ggc_marked_p (e.m_key);
      }

  private:
    template<typename T>
    static void
      pch_nx_helper (T &x, gt_pointer_operator op, void *cookie)
	{
	  gt_pch_nx (&x, op, cookie);
	}

    template<typename T>
      static void
      pch_nx_helper (T *&x, gt_pointer_operator op, void *cookie)
	{
	  op (&x, NULL, cookie);
	}

    /* The overloads below should match those in ggc.h.  */
#define DEFINE_PCH_HELPER(T)			\
    static void pch_nx_helper (T, gt_pointer_operator, void *) { }

    DEFINE_PCH_HELPER (bool);
    DEFINE_PCH_HELPER (char);
    DEFINE_PCH_HELPER (signed char);
    DEFINE_PCH_HELPER (unsigned char);
    DEFINE_PCH_HELPER (short);
    DEFINE_PCH_HELPER (unsigned short);
    DEFINE_PCH_HELPER (int);
    DEFINE_PCH_HELPER (unsigned int);
    DEFINE_PCH_HELPER (long);
    DEFINE_PCH_HELPER (unsigned long);
    DEFINE_PCH_HELPER (long long);
    DEFINE_PCH_HELPER (unsigned long long);

#undef DEFINE_PCH_HELPER
  };

public:
  explicit hash_map (size_t n = default_hash_map_size, bool ggc = false,
		     bool sanitize_eq_and_hash = true,
		     bool gather_mem_stats = GATHER_STATISTICS
		     CXX_MEM_STAT_INFO)
    : m_table (n, ggc, sanitize_eq_and_hash, gather_mem_stats,
	       HASH_MAP_ORIGIN PASS_MEM_STAT)
  {
  }

  explicit hash_map (const hash_map &h, bool ggc = false,
		     bool sanitize_eq_and_hash = true,
		     bool gather_mem_stats = GATHER_STATISTICS
		     CXX_MEM_STAT_INFO)
    : m_table (h.m_table, ggc, sanitize_eq_and_hash, gather_mem_stats,
	       HASH_MAP_ORIGIN PASS_MEM_STAT) {}

  /* Create a hash_map in ggc memory.  */
  static hash_map *create_ggc (size_t size = default_hash_map_size,
			       bool gather_mem_stats = GATHER_STATISTICS
			       CXX_MEM_STAT_INFO)
    {
      hash_map *map = ggc_alloc<hash_map> ();
      new (map) hash_map (size, true, true, gather_mem_stats PASS_MEM_STAT);
      return map;
    }

  /* If key k isn't already in the map add key k with value v to the map, and
     return false.  Otherwise set the value of the entry for key k to be v and
     return true.  */

  bool put (const Key &k, const Value &v)
    {
      hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
						   INSERT);
      bool ins = Traits::is_empty (*e);
      if (ins)
	{
	  e->m_key = k;
	  new ((void *)&e->m_value) Value (v);
	  gcc_checking_assert (!Traits::is_empty (*e)
			       && !Traits::is_deleted (*e));
	}
      else
	e->m_value = v;

      return !ins;
    }

  /* If the passed in key is in the map return pointer to its value
     otherwise NULL.  */

  Value *get (const Key &k)
    {
      hash_entry &e = m_table.find_with_hash (k, Traits::hash (k));
      return Traits::is_empty (e) ? NULL : &e.m_value;
    }

  /* Return a reference to the value for the passed in key, creating the entry
     if it doesn't already exist.  If existed is not NULL then it is set to
     false if the key was not previously in the map, and true otherwise.  */

  Value &get_or_insert (const Key &k, bool *existed = NULL)
    {
      hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
						   INSERT);
      bool ins = Traits::is_empty (*e);
      if (ins)
	{
	  e->m_key = k;
	  new ((void *)&e->m_value) Value ();
	  gcc_checking_assert (!Traits::is_empty (*e)
			       && !Traits::is_deleted (*e));
	}

      if (existed != NULL)
	*existed = !ins;

      return e->m_value;
    }

  void remove (const Key &k)
    {
      m_table.remove_elt_with_hash (k, Traits::hash (k));
    }

  /* Call the call back on each pair of key and value with the passed in
     arg until either the call back returns false or all pairs have been seen.
     The traversal is unordered.  */

  template<typename Arg, bool (*f)(const typename Traits::key_type &,
				   const Value &, Arg)>
  void traverse (Arg a) const
    {
      for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
	   iter != m_table.end (); ++iter)
	if (!f ((*iter).m_key, (*iter).m_value, a))
	  break;
    }

  template<typename Arg, bool (*f)(const typename Traits::key_type &,
				   Value *, Arg)>
  void traverse (Arg a) const
    {
      for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
	   iter != m_table.end (); ++iter)
	if (!f ((*iter).m_key, &(*iter).m_value, a))
	  break;
    }

  size_t elements () const { return m_table.elements (); }

  void empty () { m_table.empty(); }

  /* Return true when there are no elements in this hash map.  */
  bool is_empty () const { return m_table.is_empty (); }

  class iterator
  {
  public:
    explicit iterator (const typename hash_table<hash_entry>::iterator &iter) :
      m_iter (iter) {}

    iterator &operator++ ()
    {
      ++m_iter;
      return *this;
    }

    /* Can't use std::pair here, because GCC before 4.3 don't handle
       std::pair where template parameters are references well.
       See PR86739.  */
    class reference_pair {
    public:
      const Key &first;
      Value &second;

      reference_pair (const Key &key, Value &value) : first (key), second (value) {}

      template <typename K, typename V>
      operator std::pair<K, V> () const { return std::pair<K, V> (first, second); }
    };

    reference_pair operator* ()
    {
      hash_entry &e = *m_iter;
      return reference_pair (e.m_key, e.m_value);
    }

    bool operator== (const iterator &other) const
    {
      return m_iter == other.m_iter;
    }

    bool operator != (const iterator &other) const
    {
      return m_iter != other.m_iter;
    }

  private:
    typename hash_table<hash_entry>::iterator m_iter;
  };

  /* Standard iterator retrieval methods.  */

  iterator  begin () const { return iterator (m_table.begin ()); }
  iterator end () const { return iterator (m_table.end ()); }

private:

  template<typename T, typename U, typename V> friend void gt_ggc_mx (hash_map<T, U, V> *);
  template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> *);
  template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> *, gt_pointer_operator, void *);
  template<typename T, typename U, typename V> friend void gt_cleare_cache (hash_map<T, U, V> *);

  hash_table<hash_entry> m_table;
};

/* ggc marking routines.  */

template<typename K, typename V, typename H>
inline void
gt_ggc_mx (hash_map<K, V, H> *h)
{
  gt_ggc_mx (&h->m_table);
}

template<typename K, typename V, typename H>
inline void
gt_pch_nx (hash_map<K, V, H> *h)
{
  gt_pch_nx (&h->m_table);
}

template<typename K, typename V, typename H>
inline void
gt_cleare_cache (hash_map<K, V, H> *h)
{
  if (h)
    gt_cleare_cache (&h->m_table);
}

template<typename K, typename V, typename H>
inline void
gt_pch_nx (hash_map<K, V, H> *h, gt_pointer_operator op, void *cookie)
{
  op (&h->m_table.m_entries, NULL, cookie);
}

enum hm_alloc { hm_heap = false, hm_ggc = true };
template<bool ggc, typename K, typename V, typename H>
inline hash_map<K,V,H> *
hash_map_maybe_create (hash_map<K,V,H> *&h,
		       size_t size = default_hash_map_size)
{
  if (!h)
    {
      if (ggc)
	h = hash_map<K,V,H>::create_ggc (size);
      else
	h = new hash_map<K,V,H> (size);
    }
  return h;
}

/* Like h->get, but handles null h.  */
template<typename K, typename V, typename H>
inline V*
hash_map_safe_get (hash_map<K,V,H> *h, const K& k)
{
  return h ? h->get (k) : NULL;
}

/* Like h->get, but handles null h.  */
template<bool ggc, typename K, typename V, typename H>
inline V&
hash_map_safe_get_or_insert (hash_map<K,V,H> *&h, const K& k, bool *e = NULL,
			     size_t size = default_hash_map_size)
{
  return hash_map_maybe_create<ggc> (h, size)->get_or_insert (k, e);
}

/* Like h->put, but handles null h.  */
template<bool ggc, typename K, typename V, typename H>
inline bool
hash_map_safe_put (hash_map<K,V,H> *&h, const K& k, const V& v,
		   size_t size = default_hash_map_size)
{
  return hash_map_maybe_create<ggc> (h, size)->put (k, v);
}

#endif
Commit	Line	Data
1eb68d2d	1	/* A type-safe hash map.
a945c346	2	Copyright (C) 2014-2024 Free Software Foundation, Inc.
1eb68d2d TS	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20
	21	#ifndef hash_map_h
	22	#define hash_map_h
	23
7b8795a1 MS	24	/* Class hash_map is a hash-value based container mapping objects of
	25	KeyId type to those of the Value type.
	26	Both KeyId and Value may be non-trivial (non-POD) types provided
	27	a suitabe Traits class. A few default Traits specializations are
	28	provided for basic types such as integers, pointers, and std::pair.
	29	Inserted elements are value-initialized either to zero for POD types
	30	or by invoking their default ctor. Removed elements are destroyed
	31	by invoking their dtor. On hash_map destruction all elements are
	32	removed. Objects of hash_map type are copy-constructible but not
	33	assignable. */
	34
c89844e5	35	const size_t default_hash_map_size = 13;
fb5c464a	36	template<typename KeyId, typename Value,
7b8795a1 MS	37	typename Traits /* = simple_hashmap_traits<default_hash_traits<Key>,
7b8795a1 MS	38	Value> */>
b086d530	39	class GTY((user)) hash_map
1eb68d2d	40	{
fb5c464a	41	typedef typename Traits::key_type Key;
1eb68d2d TS	42	struct hash_entry
	43	{
	44	Key m_key;
	45	Value m_value;
	46
	47	typedef hash_entry value_type;
	48	typedef Key compare_type;
1eb68d2d TS	49
	50	static hashval_t hash (const hash_entry &e)
	51	{
	52	return Traits::hash (e.m_key);
	53	}
	54
	55	static bool equal (const hash_entry &a, const Key &b)
	56	{
	57	return Traits::equal_keys (a.m_key, b);
	58	}
	59
	60	static void remove (hash_entry &e) { Traits::remove (e); }
	61
	62	static void mark_deleted (hash_entry &e) { Traits::mark_deleted (e); }
	63
	64	static bool is_deleted (const hash_entry &e)
	65	{
	66	return Traits::is_deleted (e);
	67	}
	68
7ca50de0	69	static const bool empty_zero_p = Traits::empty_zero_p;
1eb68d2d TS	70	static void mark_empty (hash_entry &e) { Traits::mark_empty (e); }
1eb68d2d TS	71	static bool is_empty (const hash_entry &e) { return Traits::is_empty (e); }
b086d530 TS	72
	73	static void ggc_mx (hash_entry &e)
	74	{
	75	gt_ggc_mx (e.m_key);
	76	gt_ggc_mx (e.m_value);
	77	}
	78
21faa101 JM	79	static void ggc_maybe_mx (hash_entry &e)
	80	{
	81	if (Traits::maybe_mx)
	82	ggc_mx (e);
	83	}
	84
b086d530 TS	85	static void pch_nx (hash_entry &e)
	86	{
	87	gt_pch_nx (e.m_key);
	88	gt_pch_nx (e.m_value);
	89	}
	90
	91	static void pch_nx (hash_entry &e, gt_pointer_operator op, void *c)
	92	{
	93	pch_nx_helper (e.m_key, op, c);
	94	pch_nx_helper (e.m_value, op, c);
	95	}
	96
21faa101 JM	97	static int keep_cache_entry (hash_entry &e)
	98	{
	99	return ggc_marked_p (e.m_key);
	100	}
	101
b086d530 TS	102	private:
	103	template<typename T>
	104	static void
	105	pch_nx_helper (T &x, gt_pointer_operator op, void *cookie)
	106	{
	107	gt_pch_nx (&x, op, cookie);
	108	}
	109
b086d530 TS	110	template<typename T>
	111	static void
	112	pch_nx_helper (T &x, gt_pointer_operator op, void cookie)
	113	{
747380f4	114	op (&x, NULL, cookie);
b086d530	115	}
5d05e83e MS	116
	117	/* The overloads below should match those in ggc.h. */
	118	#define DEFINE_PCH_HELPER(T) \
	119	static void pch_nx_helper (T, gt_pointer_operator, void *) { }
	120
	121	DEFINE_PCH_HELPER (bool);
	122	DEFINE_PCH_HELPER (char);
	123	DEFINE_PCH_HELPER (signed char);
	124	DEFINE_PCH_HELPER (unsigned char);
	125	DEFINE_PCH_HELPER (short);
	126	DEFINE_PCH_HELPER (unsigned short);
	127	DEFINE_PCH_HELPER (int);
	128	DEFINE_PCH_HELPER (unsigned int);
	129	DEFINE_PCH_HELPER (long);
	130	DEFINE_PCH_HELPER (unsigned long);
	131	DEFINE_PCH_HELPER (long long);
	132	DEFINE_PCH_HELPER (unsigned long long);
	133
	134	#undef DEFINE_PCH_HELPER
1eb68d2d TS	135	};
	136
	137	public:
c89844e5	138	explicit hash_map (size_t n = default_hash_map_size, bool ggc = false,
ff7b3aa5	139	bool sanitize_eq_and_hash = true,
f5c08287 MM	140	bool gather_mem_stats = GATHER_STATISTICS
f5c08287 MM	141	CXX_MEM_STAT_INFO)
ff7b3aa5 ML	142	: m_table (n, ggc, sanitize_eq_and_hash, gather_mem_stats,
ff7b3aa5 ML	143	HASH_MAP_ORIGIN PASS_MEM_STAT)
48f8fefe ML	144	{
48f8fefe ML	145	}
b086d530	146
951c9e90	147	explicit hash_map (const hash_map &h, bool ggc = false,
ff7b3aa5	148	bool sanitize_eq_and_hash = true,
951c9e90 JM	149	bool gather_mem_stats = GATHER_STATISTICS
951c9e90 JM	150	CXX_MEM_STAT_INFO)
ff7b3aa5	151	: m_table (h.m_table, ggc, sanitize_eq_and_hash, gather_mem_stats,
fa583f9e JM	152	HASH_MAP_ORIGIN PASS_MEM_STAT) {}
fa583f9e JM	153
b086d530	154	/* Create a hash_map in ggc memory. */
c89844e5	155	static hash_map *create_ggc (size_t size = default_hash_map_size,
f5c08287	156	bool gather_mem_stats = GATHER_STATISTICS
2d44c7de	157	CXX_MEM_STAT_INFO)
b086d530 TS	158	{
b086d530 TS	159	hash_map *map = ggc_alloc<hash_map> ();
ff7b3aa5	160	new (map) hash_map (size, true, true, gather_mem_stats PASS_MEM_STAT);
b086d530 TS	161	return map;
b086d530 TS	162	}
1eb68d2d TS	163
	164	/* If key k isn't already in the map add key k with value v to the map, and
	165	return false. Otherwise set the value of the entry for key k to be v and
	166	return true. */
	167
	168	bool put (const Key &k, const Value &v)
	169	{
	170	hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
	171	INSERT);
8d481077	172	bool ins = Traits::is_empty (*e);
7b8795a1 MS	173	if (ins)
	174	{
	175	e->m_key = k;
603da201 AO	176	new ((void *)&e->m_value) Value (v);
	177	gcc_checking_assert (!Traits::is_empty (*e)
	178	&& !Traits::is_deleted (*e));
7b8795a1 MS	179	}
	180	else
	181	e->m_value = v;
1eb68d2d	182
7b8795a1	183	return !ins;
1eb68d2d TS	184	}
1eb68d2d TS	185
bf567bb3 NS	186	/* If the passed in key is in the map return pointer to its value
bf567bb3 NS	187	otherwise NULL. */
1eb68d2d TS	188
	189	Value *get (const Key &k)
	190	{
	191	hash_entry &e = m_table.find_with_hash (k, Traits::hash (k));
	192	return Traits::is_empty (e) ? NULL : &e.m_value;
	193	}
	194
	195	/* Return a reference to the value for the passed in key, creating the entry
7b8795a1 MS	196	if it doesn't already exist. If existed is not NULL then it is set to
7b8795a1 MS	197	false if the key was not previously in the map, and true otherwise. */
1eb68d2d TS	198
	199	Value &get_or_insert (const Key &k, bool *existed = NULL)
	200	{
	201	hash_entry *e = m_table.find_slot_with_hash (k, Traits::hash (k),
	202	INSERT);
	203	bool ins = Traits::is_empty (*e);
	204	if (ins)
7b8795a1 MS	205	{
	206	e->m_key = k;
	207	new ((void *)&e->m_value) Value ();
603da201 AO	208	gcc_checking_assert (!Traits::is_empty (*e)
603da201 AO	209	&& !Traits::is_deleted (*e));
7b8795a1	210	}
1eb68d2d TS	211
	212	if (existed != NULL)
	213	*existed = !ins;
	214
	215	return e->m_value;
	216	}
	217
b787e7a2 TS	218	void remove (const Key &k)
	219	{
	220	m_table.remove_elt_with_hash (k, Traits::hash (k));
	221	}
	222
1eb68d2d	223	/* Call the call back on each pair of key and value with the passed in
c93e704b MK	224	arg until either the call back returns false or all pairs have been seen.
c93e704b MK	225	The traversal is unordered. */
1eb68d2d	226
5265e7ba RS	227	template<typename Arg, bool (*f)(const typename Traits::key_type &,
5265e7ba RS	228	const Value &, Arg)>
1eb68d2d TS	229	void traverse (Arg a) const
	230	{
	231	for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
	232	iter != m_table.end (); ++iter)
c93e704b MK	233	if (!f ((iter).m_key, (iter).m_value, a))
c93e704b MK	234	break;
1eb68d2d TS	235	}
1eb68d2d TS	236
5265e7ba RS	237	template<typename Arg, bool (*f)(const typename Traits::key_type &,
5265e7ba RS	238	Value *, Arg)>
b787e7a2 TS	239	void traverse (Arg a) const
	240	{
	241	for (typename hash_table<hash_entry>::iterator iter = m_table.begin ();
	242	iter != m_table.end (); ++iter)
	243	if (!f ((iter).m_key, &(iter).m_value, a))
	244	break;
	245	}
	246
f1308e4b RB	247	size_t elements () const { return m_table.elements (); }
f1308e4b RB	248
e45639f3 JM	249	void empty () { m_table.empty(); }
e45639f3 JM	250
b119c055 ML	251	/* Return true when there are no elements in this hash map. */
	252	bool is_empty () const { return m_table.is_empty (); }
	253
de144fb2 TS	254	class iterator
	255	{
	256	public:
	257	explicit iterator (const typename hash_table<hash_entry>::iterator &iter) :
	258	m_iter (iter) {}
	259
	260	iterator &operator++ ()
	261	{
	262	++m_iter;
	263	return *this;
	264	}
	265
12763abc JJ	266	/* Can't use std::pair here, because GCC before 4.3 don't handle
	267	std::pair where template parameters are references well.
	268	See PR86739. */
6c1dae73 MS	269	class reference_pair {
6c1dae73 MS	270	public:
12763abc JJ	271	const Key &first;
	272	Value &second;
	273
	274	reference_pair (const Key &key, Value &value) : first (key), second (value) {}
	275
	276	template <typename K, typename V>
	277	operator std::pair<K, V> () const { return std::pair<K, V> (first, second); }
	278	};
	279
	280	reference_pair operator* ()
de144fb2 TS	281	{
de144fb2 TS	282	hash_entry &e = *m_iter;
12763abc	283	return reference_pair (e.m_key, e.m_value);
de144fb2 TS	284	}
de144fb2 TS	285
5d05e83e MS	286	bool operator== (const iterator &other) const
	287	{
	288	return m_iter == other.m_iter;
	289	}
	290
	291	bool operator != (const iterator &other) const
de144fb2 TS	292	{
	293	return m_iter != other.m_iter;
	294	}
	295
	296	private:
	297	typename hash_table<hash_entry>::iterator m_iter;
	298	};
	299
	300	/* Standard iterator retrieval methods. */
	301
	302	iterator begin () const { return iterator (m_table.begin ()); }
	303	iterator end () const { return iterator (m_table.end ()); }
	304
1eb68d2d	305	private:
b086d530 TS	306
	307	template<typename T, typename U, typename V> friend void gt_ggc_mx (hash_map<T, U, V> *);
	308	template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> *);
21faa101 JM	309	template<typename T, typename U, typename V> friend void gt_pch_nx (hash_map<T, U, V> , gt_pointer_operator, void );
21faa101 JM	310	template<typename T, typename U, typename V> friend void gt_cleare_cache (hash_map<T, U, V> *);
b086d530	311
1eb68d2d TS	312	hash_table<hash_entry> m_table;
	313	};
	314
b086d530 TS	315	/* ggc marking routines. */
	316
	317	template<typename K, typename V, typename H>
cb3e0eac	318	inline void
b086d530 TS	319	gt_ggc_mx (hash_map<K, V, H> *h)
	320	{
	321	gt_ggc_mx (&h->m_table);
	322	}
	323
	324	template<typename K, typename V, typename H>
cb3e0eac	325	inline void
b086d530 TS	326	gt_pch_nx (hash_map<K, V, H> *h)
	327	{
	328	gt_pch_nx (&h->m_table);
	329	}
	330
21faa101	331	template<typename K, typename V, typename H>
cb3e0eac	332	inline void
21faa101 JM	333	gt_cleare_cache (hash_map<K, V, H> *h)
21faa101 JM	334	{
04f91503 MT	335	if (h)
04f91503 MT	336	gt_cleare_cache (&h->m_table);
21faa101 JM	337	}
21faa101 JM	338
b086d530	339	template<typename K, typename V, typename H>
cb3e0eac	340	inline void
b086d530 TS	341	gt_pch_nx (hash_map<K, V, H> h, gt_pointer_operator op, void cookie)
b086d530 TS	342	{
747380f4	343	op (&h->m_table.m_entries, NULL, cookie);
b086d530 TS	344	}
b086d530 TS	345
c89844e5 JM	346	enum hm_alloc { hm_heap = false, hm_ggc = true };
	347	template<bool ggc, typename K, typename V, typename H>
	348	inline hash_map<K,V,H> *
	349	hash_map_maybe_create (hash_map<K,V,H> *&h,
	350	size_t size = default_hash_map_size)
	351	{
	352	if (!h)
	353	{
	354	if (ggc)
	355	h = hash_map<K,V,H>::create_ggc (size);
	356	else
	357	h = new hash_map<K,V,H> (size);
	358	}
	359	return h;
	360	}
	361
	362	/* Like h->get, but handles null h. */
	363	template<typename K, typename V, typename H>
	364	inline V*
	365	hash_map_safe_get (hash_map<K,V,H> *h, const K& k)
	366	{
	367	return h ? h->get (k) : NULL;
	368	}
	369
	370	/* Like h->get, but handles null h. */
	371	template<bool ggc, typename K, typename V, typename H>
	372	inline V&
	373	hash_map_safe_get_or_insert (hash_map<K,V,H> &h, const K& k, bool e = NULL,
	374	size_t size = default_hash_map_size)
	375	{
	376	return hash_map_maybe_create<ggc> (h, size)->get_or_insert (k, e);
	377	}
	378
	379	/* Like h->put, but handles null h. */
	380	template<bool ggc, typename K, typename V, typename H>
	381	inline bool
	382	hash_map_safe_put (hash_map<K,V,H> *&h, const K& k, const V& v,
	383	size_t size = default_hash_map_size)
	384	{
	385	return hash_map_maybe_create<ggc> (h, size)->put (k, v);
	386	}
	387
1eb68d2d	388	#endif