gcc/hash-map-traits.h

   1 /* A hash map traits.
   2    Copyright (C) 2015-2020 Free Software Foundation, Inc.
   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 #ifndef HASH_MAP_TRAITS_H
  21 #define HASH_MAP_TRAITS_H
  22
  23 /* Bacause mem-stats.h uses default hashmap traits, we have to
  24    put the class to this separate header file.  */
  25
  26 #include "hash-traits.h"
  27
  28 /* Implement hash_map traits for a key with hash traits H.  Empty and
  29    deleted map entries are represented as empty and deleted keys.  */
  30
  31 template <typename H, typename Value>
  32 struct simple_hashmap_traits
  33 {
  34   typedef typename H::value_type key_type;
  35   static const bool maybe_mx = true;
  36   static inline hashval_t hash (const key_type &);
  37   static inline bool equal_keys (const key_type &, const key_type &);
  38   template <typename T> static inline void remove (T &);
  39   template <typename T> static inline bool is_empty (const T &);
  40   template <typename T> static inline bool is_deleted (const T &);
  41   template <typename T> static inline void mark_empty (T &);
  42   template <typename T> static inline void mark_deleted (T &);
  43 };
  44
  45 template <typename H, typename Value>
  46 inline hashval_t
  47 simple_hashmap_traits <H, Value>::hash (const key_type &h)
  48 {
  49   return H::hash (h);
  50 }
  51
  52 template <typename H, typename Value>
  53 inline bool
  54 simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
  55                                               const key_type &k2)
  56 {
  57   return H::equal (k1, k2);
  58 }
  59
  60 template <typename H, typename Value>
  61 template <typename T>
  62 inline void
  63 simple_hashmap_traits <H, Value>::remove (T &entry)
  64 {
  65   H::remove (entry.m_key);
  66   entry.m_value.~Value ();
  67 }
  68
  69 template <typename H, typename Value>
  70 template <typename T>
  71 inline bool
  72 simple_hashmap_traits <H, Value>::is_empty (const T &entry)
  73 {
  74   return H::is_empty (entry.m_key);
  75 }
  76
  77 template <typename H, typename Value>
  78 template <typename T>
  79 inline bool
  80 simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
  81 {
  82   return H::is_deleted (entry.m_key);
  83 }
  84
  85 template <typename H, typename Value>
  86 template <typename T>
  87 inline void
  88 simple_hashmap_traits <H, Value>::mark_empty (T &entry)
  89 {
  90   H::mark_empty (entry.m_key);
  91 }
  92
  93 template <typename H, typename Value>
  94 template <typename T>
  95 inline void
  96 simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
  97 {
  98   H::mark_deleted (entry.m_key);
  99 }
 100
 101 template <typename H, typename Value>
 102 struct simple_cache_map_traits: public simple_hashmap_traits<H,Value>
 103 {
 104   static const bool maybe_mx = false;
 105 };
 106
 107 /* Implement traits for a hash_map with values of type Value for cases
 108    in which the key cannot represent empty and deleted slots.  Instead
 109    record empty and deleted entries in Value.  Derived classes must
 110    implement the hash and equal_keys functions.  */
 111
 112 template <typename Value>
 113 struct unbounded_hashmap_traits
 114 {
 115   template <typename T> static inline void remove (T &);
 116   template <typename T> static inline bool is_empty (const T &);
 117   template <typename T> static inline bool is_deleted (const T &);
 118   template <typename T> static inline void mark_empty (T &);
 119   template <typename T> static inline void mark_deleted (T &);
 120 };
 121
 122 template <typename Value>
 123 template <typename T>
 124 inline void
 125 unbounded_hashmap_traits <Value>::remove (T &entry)
 126 {
 127   default_hash_traits <Value>::remove (entry.m_value);
 128 }
 129
 130 template <typename Value>
 131 template <typename T>
 132 inline bool
 133 unbounded_hashmap_traits <Value>::is_empty (const T &entry)
 134 {
 135   return default_hash_traits <Value>::is_empty (entry.m_value);
 136 }
 137
 138 template <typename Value>
 139 template <typename T>
 140 inline bool
 141 unbounded_hashmap_traits <Value>::is_deleted (const T &entry)
 142 {
 143   return default_hash_traits <Value>::is_deleted (entry.m_value);
 144 }
 145
 146 template <typename Value>
 147 template <typename T>
 148 inline void
 149 unbounded_hashmap_traits <Value>::mark_empty (T &entry)
 150 {
 151   default_hash_traits <Value>::mark_empty (entry.m_value);
 152 }
 153
 154 template <typename Value>
 155 template <typename T>
 156 inline void
 157 unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
 158 {
 159   default_hash_traits <Value>::mark_deleted (entry.m_value);
 160 }
 161
 162 /* Implement traits for a hash_map from integer type Key to Value in
 163    cases where Key has no spare values for recording empty and deleted
 164    slots.  */
 165
 166 template <typename Key, typename Value>
 167 struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
 168 {
 169   typedef Key key_type;
 170   static inline hashval_t hash (Key);
 171   static inline bool equal_keys (Key, Key);
 172 };
 173
 174 template <typename Key, typename Value>
 175 inline hashval_t
 176 unbounded_int_hashmap_traits <Key, Value>::hash (Key k)
 177 {
 178   return k;
 179 }
 180
 181 template <typename Key, typename Value>
 182 inline bool
 183 unbounded_int_hashmap_traits <Key, Value>::equal_keys (Key k1, Key k2)
 184 {
 185   return k1 == k2;
 186 }
 187
 188 #endif // HASH_MAP_TRAITS_H