re PR target/65697 (__atomic memory barriers not strong enough for __sync builtins)

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

diff --git a/gcc/hash-map-traits.h b/gcc/hash-map-traits.h
index 9cab0ec66c7464ef2ecc819445d0eb1b86fb237d..2225426e365caac7832c4dd79ae15485ed292954 100644 (file)
--- a/gcc/hash-map-traits.h
+++ b/gcc/hash-map-traits.h
@@ -25,93 +25,15 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "hash-traits.h"
 
-/* implement default behavior for traits when types allow it.  */
-
-struct default_hashmap_traits
-{
-  /* Hashes the passed in key.  */
-
-  template<typename T>
-  static hashval_t
-  hash (T *p)
-    {
-      return uintptr_t (p) >> 3;
-    }
-
-  /* If the value converts to hashval_t just use it.  */
-
-  template<typename T> static hashval_t hash (T v) { return v; }
-
-  /* Return true if the two keys passed as arguments are equal.  */
-
-  template<typename T>
-  static bool
-  equal_keys (const T &a, const T &b)
-    {
-      return a == b;
-    }
-
-  /* Called to dispose of the key and value before marking the entry as
-     deleted.  */
-
-  template<typename T> static void remove (T &v) { v.~T (); }
-
-  /* Mark the passed in entry as being deleted.  */
-
-  template<typename T>
-  static void
-  mark_deleted (T &e)
-    {
-      mark_key_deleted (e.m_key);
-    }
-
-  /* Mark the passed in entry as being empty.  */
-
-  template<typename T>
-  static void
-  mark_empty (T &e)
-    {
-      mark_key_empty (e.m_key);
-    }
-
-  /* Return true if the passed in entry is marked as deleted.  */
-
-  template<typename T>
-  static bool
-  is_deleted (T &e)
-    {
-      return e.m_key == (void *)1;
-    }
-
-  /* Return true if the passed in entry is marked as empty.  */
-
-  template<typename T> static bool is_empty (T &e) { return e.m_key == NULL; }
-
-private:
-  template<typename T>
-  static void
-  mark_key_deleted (T *&k)
-    {
-      k = reinterpret_cast<T *> (1);
-    }
-
-  template<typename T>
-  static void
-  mark_key_empty (T *&k)
-    {
-      k = static_cast<T *> (0);
-    }
-};
-
 /* Implement hash_map traits for a key with hash traits H.  Empty and
    deleted map entries are represented as empty and deleted keys.  */
 
 template <typename H>
 struct simple_hashmap_traits
 {
-  static inline hashval_t hash (const typename H::value_type &);
-  static inline bool equal_keys (const typename H::value_type &,
-                                const typename H::value_type &);
+  typedef typename H::value_type key_type;
+  static inline hashval_t hash (const key_type &);
+  static inline bool equal_keys (const key_type &, const key_type &);
   template <typename T> static inline void remove (T &);
   template <typename T> static inline bool is_empty (const T &);
   template <typename T> static inline bool is_deleted (const T &);
@@ -121,15 +43,14 @@ struct simple_hashmap_traits
 
 template <typename H>
 inline hashval_t
-simple_hashmap_traits <H>::hash (const typename H::value_type &h)
+simple_hashmap_traits <H>::hash (const key_type &h)
 {
   return H::hash (h);
 }
 
 template <typename H>
 inline bool
-simple_hashmap_traits <H>::equal_keys (const typename H::value_type &k1,
-                                      const typename H::value_type &k2)
+simple_hashmap_traits <H>::equal_keys (const key_type &k1, const key_type &k2)
 {
   return H::equal (k1, k2);
 }
@@ -236,6 +157,7 @@ unbounded_hashmap_traits <Value>::mark_deleted (T &entry)
 template <typename Key, typename Value>
 struct unbounded_int_hashmap_traits : unbounded_hashmap_traits <Value>
 {
+  typedef Key key_type;
   static inline hashval_t hash (Key);
   static inline bool equal_keys (Key, Key);
 };