1 | /* A hash map traits. |
---|---|

2 | Copyright (C) 2015-2017 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 |

189 |