Patchwork Merge C++ conversion into trunk (4/6 - hash table rewrite)

login
register
mail settings
Submitter Richard Guenther
Date Aug. 15, 2012, 1:38 p.m.
Message ID <alpine.LNX.2.00.1208151534410.28649@zhemvz.fhfr.qr>
Download mbox | patch
Permalink /patch/177645/
State New
Headers show

Comments

Richard Guenther - Aug. 15, 2012, 1:38 p.m.
On Wed, 15 Aug 2012, Richard Guenther wrote:

> On Sun, 12 Aug 2012, Diego Novillo wrote:
> 
> > This implements a new C++ hash table.
> > 
> > See http://gcc.gnu.org/ml/gcc-patches/2012-08/msg00711.html for
> > details.
> > 
> > Diego.
> 
> Now as we see the result I'd have prefered a more C++-way instead
> of making the conversion simple ...
> 
> Like
> 
> template <typename Element>
> class hash_table
> {
> ...
> };
> 
> template <typename Element>
> class pointer_hash
> {
>   hashval_t hash ();
>   int equal (const Element *);
>   ~Element ();
>   Element e;
> };
> 
> and
> 
> /* Hash table with all same_succ entries.  */
> 
> static hash_table <pointer_hash <struct same_succ_def> > same_succ_htab;
> 
> The existing way is simply too ugly ... so, why did you not invent
> a "nice" C++ way?

Like the following, only the coverage.c use is converted.  I've
never seen template function arguments anywhere and having to repeat
them all over the place is really really ugly (yes, even if only in
the implementation).

This goes with static member functions and not wrapping any data.
It goes away with the requirement of having externally visible
global functions for the hash/compare functions as well (which was
ugly anyway).

Comments?

Thanks,
Richard.

> diffstat ~/p
 coverage.c   |   43 +++++-----
 hash-table.h |  234 
+++++++++++++++++++++--------------------------------------
 2 files changed, 108 insertions(+), 169 deletions(-)
Michael Matz - Aug. 15, 2012, 2:05 p.m.
Hi,

On Wed, 15 Aug 2012, Richard Guenther wrote:

> Like the following, only the coverage.c use is converted.  I've never 
> seen template function arguments anywhere and having to repeat them all 
> over the place is really really ugly (yes, even if only in the 
> implementation).
> 
> This goes with static member functions and not wrapping any data. It 
> goes away with the requirement of having externally visible global 
> functions for the hash/compare functions as well (which was ugly 
> anyway).
> 
> Comments?

Well, it looks nicer than what's there currently.  As the element 
functions now are scoped and normal member functions, they should be named 
with lower case characters of course.  I do like that the hash table would 
then only have one real template argument; the Allocator, well, no better 
idea comes to my mind.


Ciao,
Michael.
Richard Guenther - Aug. 15, 2012, 2:29 p.m.
On Wed, 15 Aug 2012, Michael Matz wrote:

> Hi,
> 
> On Wed, 15 Aug 2012, Richard Guenther wrote:
> 
> > Like the following, only the coverage.c use is converted.  I've never 
> > seen template function arguments anywhere and having to repeat them all 
> > over the place is really really ugly (yes, even if only in the 
> > implementation).
> > 
> > This goes with static member functions and not wrapping any data. It 
> > goes away with the requirement of having externally visible global 
> > functions for the hash/compare functions as well (which was ugly 
> > anyway).
> > 
> > Comments?
> 
> Well, it looks nicer than what's there currently.  As the element 
> functions now are scoped and normal member functions, they should be named 
> with lower case characters of course.  I do like that the hash table would 
> then only have one real template argument; the Allocator, well, no better 
> idea comes to my mind.

Yeah.  Updated patch below, all users converted.  I probably missed
to revert some of the globalizations of hash/compare fns.

Comments?
Richard.

Index: gcc/hash-table.h
===================================================================
*** gcc/hash-table.h.orig	2012-08-15 15:39:34.000000000 +0200
--- gcc/hash-table.h	2012-08-15 16:17:06.613628039 +0200
*************** xcallocator <Type>::data_free (Type *mem
*** 83,127 ****
  }
  
  
- /* A common function for hashing a CANDIDATE typed pointer.  */
- 
  template <typename Element>
! inline hashval_t
! typed_pointer_hash (const Element *candidate)
  {
!   /* This is a really poor hash function, but it is what the current code uses,
!      so I am reusing it to avoid an additional axis in testing.  */
!   return (hashval_t) ((intptr_t)candidate >> 3);
! }
  
  
- /* A common function for comparing an EXISTING and CANDIDATE typed pointers
-    for equality. */
  
  template <typename Element>
! inline int
! typed_pointer_equal (const Element *existing, const Element * candidate)
  {
!   return existing == candidate;
! }
  
  
! /* A common function for doing nothing on removing a RETIRED slot.  */
  
  template <typename Element>
! inline void
! typed_null_remove (Element *retired ATTRIBUTE_UNUSED)
  {
  }
  
- 
- /* A common function for using free on removing a RETIRED slot.  */
- 
  template <typename Element>
! inline void
! typed_free_remove (Element *retired)
  {
!   free (retired);
  }
  
  
--- 83,132 ----
  }
  
  
  template <typename Element>
! class typed_free_remove
  {
! public:
!   static inline void remove (Element *p) { free (p); }
! };
  
+ template <typename Element>
+ class typed_noop_remove
+ {
+ public:
+   static inline void remove (Element *) {}
+ };
  
  
+ /* Pointer hash.  */
  template <typename Element>
! class pointer_hash : public typed_noop_remove <Element>
  {
! public:
!   typedef Element Element_t;
  
+   static inline hashval_t
+   hash (const Element_t *);
  
!   static inline int
!   equal (const Element_t *existing, const Element_t * candidate);
! };
  
  template <typename Element>
! inline hashval_t
! pointer_hash<Element>::hash (const Element_t *candidate)
  {
+   /* This is a really poor hash function, but it is what the current code uses,
+      so I am reusing it to avoid an additional axis in testing.  */
+   return (hashval_t) ((intptr_t)candidate >> 3);
  }
  
  template <typename Element>
! inline int
! pointer_hash<Element>::equal (const Element_t *existing,
! 			      const Element_t *candidate)
  {
!   return existing == candidate;
  }
  
  
*************** struct hash_table_control
*** 180,194 ****
  
     The table stores elements of type Element.
  
!    It hashes elements with the Hash function.
       The table currently works with relatively weak hash functions.
       Use typed_pointer_hash <Element> when hashing pointers instead of objects.
  
!    It compares elements with the Equal function.
       Two elements with the same hash may not be equal.
       Use typed_pointer_equal <Element> when hashing pointers instead of objects.
  
!    It removes elements with the Remove function.
       This feature is useful for freeing memory.
       Use typed_null_remove <Element> when not freeing objects.
       Use typed_free_remove <Element> when doing a simple object free.
--- 185,199 ----
  
     The table stores elements of type Element.
  
!    It hashes elements with the hash function.
       The table currently works with relatively weak hash functions.
       Use typed_pointer_hash <Element> when hashing pointers instead of objects.
  
!    It compares elements with the equal function.
       Two elements with the same hash may not be equal.
       Use typed_pointer_equal <Element> when hashing pointers instead of objects.
  
!    It removes elements with the remove function.
       This feature is useful for freeing memory.
       Use typed_null_remove <Element> when not freeing objects.
       Use typed_free_remove <Element> when doing a simple object free.
*************** struct hash_table_control
*** 199,243 ****
  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator = xcallocator>
  class hash_table
  {
  
  private:
  
!   hash_table_control <Element> *htab;
! 
!   Element **find_empty_slot_for_expand (hashval_t hash);
    void expand ();
  
  public:
- 
    hash_table ();
    void create (size_t initial_slots);
    bool is_created ();
    void dispose ();
!   Element *find (Element *comparable);
!   Element *find_with_hash (Element *comparable, hashval_t hash);
!   Element **find_slot (Element *comparable, enum insert_option insert);
!   Element **find_slot_with_hash (Element *comparable, hashval_t hash,
! 				 enum insert_option insert);
    void empty ();
!   void clear_slot (Element **slot);
!   void remove_elt (Element *comparable);
!   void remove_elt_with_hash (Element *comparable, hashval_t hash);
    size_t size();
    size_t elements();
    double collisions();
  
    template <typename Argument,
! 	    int (*Callback) (Element **slot, Argument argument)>
    void traverse_noresize (Argument argument);
  
    template <typename Argument,
! 	    int (*Callback) (Element **slot, Argument argument)>
    void traverse (Argument argument);
  };
  
--- 204,245 ----
  */
  
  template <typename Element,
  	  template <typename Type> class Allocator = xcallocator>
  class hash_table
  {
+ public:
+   typedef typename Element::Element_t Element_t;
  
  private:
+   hash_table_control <Element_t> *htab;
  
!   Element_t **find_empty_slot_for_expand (hashval_t hash);
    void expand ();
  
  public:
    hash_table ();
    void create (size_t initial_slots);
    bool is_created ();
    void dispose ();
!   Element_t *find (Element_t *comparable);
!   Element_t *find_with_hash (Element_t *comparable, hashval_t hash);
!   Element_t **find_slot (Element_t *comparable, enum insert_option insert);
!   Element_t **find_slot_with_hash (Element_t *comparable, hashval_t hash,
! 				   enum insert_option insert);
    void empty ();
!   void clear_slot (Element_t **slot);
!   void remove_elt (Element_t *comparable);
!   void remove_elt_with_hash (Element_t *comparable, hashval_t hash);
    size_t size();
    size_t elements();
    double collisions();
  
    template <typename Argument,
! 	    int (*Callback) (Element_t **slot, Argument argument)>
    void traverse_noresize (Argument argument);
  
    template <typename Argument,
! 	    int (*Callback) (Element_t **slot, Argument argument)>
    void traverse (Argument argument);
  };
  
*************** public:
*** 245,256 ****
  /* Construct the hash table.  The only useful operation next is create.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline
! hash_table <Element, Hash, Equal, Remove, Allocator>::hash_table ()
  : htab (NULL)
  {
  }
--- 247,255 ----
  /* Construct the hash table.  The only useful operation next is create.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  inline
! hash_table <Element, Allocator>::hash_table ()
  : htab (NULL)
  {
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 259,270 ****
  /* See if the table has been created, as opposed to constructed.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline bool
! hash_table <Element, Hash, Equal, Remove, Allocator>::is_created ()
  {
    return htab != NULL;
  }
--- 258,266 ----
  /* See if the table has been created, as opposed to constructed.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  inline bool
! hash_table <Element, Allocator>::is_created ()
  {
    return htab != NULL;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 273,328 ****
  /* Like find_with_hash, but compute the hash value from the element.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
! inline Element *
! hash_table <Element, Hash, Equal, Remove, Allocator>::find (Element *comparable)
  {
!   return find_with_hash (comparable, Hash (comparable));
  }
  
  
  /* Like find_slot_with_hash, but compute the hash value from the element.  */
  
  template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
! 	  template <typename Type> class Allocator>
! inline Element **
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::find_slot (Element *comparable, enum insert_option insert)
  {
!   return find_slot_with_hash (comparable, Hash (comparable), insert);
  }
  
  
  /* Like remove_elt_with_hash, but compute the hash value from the element.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline void
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::remove_elt (Element *comparable)
  {
!   remove_elt_with_hash (comparable, Hash (comparable));
  }
  
  
  /* Return the current size of this hash table.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Element, Hash, Equal, Remove, Allocator>::size()
  {
    return htab->size;
  }
--- 269,312 ----
  /* Like find_with_hash, but compute the hash value from the element.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
! inline typename Element::Element_t *
! hash_table <Element, Allocator>::find (Element_t *comparable)
  {
!   return find_with_hash (comparable, Element::hash (comparable));
  }
  
  
  /* Like find_slot_with_hash, but compute the hash value from the element.  */
  
  template <typename Element,
! 	  template <typename Type> class Allocator>
! inline typename Element::Element_t **
! hash_table <Element, Allocator>
! ::find_slot (Element_t *comparable, enum insert_option insert)
  {
!   return find_slot_with_hash (comparable, Element::hash (comparable), insert);
  }
  
  
  /* Like remove_elt_with_hash, but compute the hash value from the element.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  inline void
! hash_table <Element, Allocator>
! ::remove_elt (Element_t *comparable)
  {
!   remove_elt_with_hash (comparable, Element::hash (comparable));
  }
  
  
  /* Return the current size of this hash table.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Element, Allocator>::size()
  {
    return htab->size;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 331,342 ****
  /* Return the current number of elements in this hash table. */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Element, Hash, Equal, Remove, Allocator>::elements()
  {
    return htab->n_elements - htab->n_deleted;
  }
--- 315,323 ----
  /* Return the current number of elements in this hash table. */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Element, Allocator>::elements()
  {
    return htab->n_elements - htab->n_deleted;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 346,357 ****
       hash table. */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline double
! hash_table <Element, Hash, Equal, Remove, Allocator>::collisions()
  {
    if (htab->searches == 0)
      return 0.0;
--- 327,335 ----
       hash table. */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  inline double
! hash_table <Element, Allocator>::collisions()
  {
    if (htab->searches == 0)
      return 0.0;
*************** hash_table <Element, Hash, Equal, Remove
*** 363,383 ****
  /* Create a hash table with at least the given number of INITIAL_SLOTS.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::create (size_t size)
  {
    unsigned int size_prime_index;
  
    size_prime_index = hash_table_higher_prime_index (size);
    size = prime_tab[size_prime_index].prime;
  
!   htab = Allocator <hash_table_control <Element> > ::control_alloc (1);
    gcc_assert (htab != NULL);
!   htab->entries = Allocator <Element*> ::data_alloc (size);
    gcc_assert (htab->entries != NULL);
    htab->size = size;
    htab->size_prime_index = size_prime_index;
--- 341,358 ----
  /* Create a hash table with at least the given number of INITIAL_SLOTS.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Allocator>::create (size_t size)
  {
    unsigned int size_prime_index;
  
    size_prime_index = hash_table_higher_prime_index (size);
    size = prime_tab[size_prime_index].prime;
  
!   htab = Allocator <hash_table_control <Element_t> > ::control_alloc (1);
    gcc_assert (htab != NULL);
!   htab->entries = Allocator <Element_t*> ::data_alloc (size);
    gcc_assert (htab->entries != NULL);
    htab->size = size;
    htab->size_prime_index = size_prime_index;
*************** hash_table <Element, Hash, Equal, Remove
*** 388,432 ****
     the non-created state.  Naturally the hash table must already exist.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::dispose ()
  {
    size_t size = htab->size;
!   Element **entries = htab->entries;
  
    for (int i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Remove (entries[i]);
  
!   Allocator <Element *> ::data_free (entries);
!   Allocator <hash_table_control <Element> > ::control_free (htab);
    htab = NULL;
  }
  
  
  /* Similar to find_slot, but without several unwanted side effects:
!     - Does not call Equal when it finds an existing entry.
      - Does not change the count of elements/searches/collisions in the
        hash table.
     This function also assumes there are no deleted entries in the table.
     HASH is the hash value for the element to be inserted.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
! Element **
! hash_table <Element, Hash, Equal, Remove, Allocator>
  ::find_empty_slot_for_expand (hashval_t hash)
  {
    hashval_t index = hash_table_mod1 (hash, htab->size_prime_index);
    size_t size = htab->size;
!   Element **slot = htab->entries + index;
    hashval_t hash2;
  
    if (*slot == HTAB_EMPTY_ENTRY)
--- 363,401 ----
     the non-created state.  Naturally the hash table must already exist.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Allocator>::dispose ()
  {
    size_t size = htab->size;
!   Element_t **entries = htab->entries;
  
    for (int i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Element::remove (entries[i]);
  
!   Allocator <Element_t *> ::data_free (entries);
!   Allocator <hash_table_control <Element_t> > ::control_free (htab);
    htab = NULL;
  }
  
  
  /* Similar to find_slot, but without several unwanted side effects:
!     - Does not call equal when it finds an existing entry.
      - Does not change the count of elements/searches/collisions in the
        hash table.
     This function also assumes there are no deleted entries in the table.
     HASH is the hash value for the element to be inserted.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
! typename Element::Element_t **
! hash_table <Element, Allocator>
  ::find_empty_slot_for_expand (hashval_t hash)
  {
    hashval_t index = hash_table_mod1 (hash, htab->size_prime_index);
    size_t size = htab->size;
!   Element_t **slot = htab->entries + index;
    hashval_t hash2;
  
    if (*slot == HTAB_EMPTY_ENTRY)
*************** hash_table <Element, Hash, Equal, Remove
*** 458,474 ****
     will abort.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::expand ()
  {
!   Element **oentries;
!   Element **olimit;
!   Element **p;
!   Element **nentries;
    size_t nsize, osize, elts;
    unsigned int oindex, nindex;
  
--- 427,440 ----
     will abort.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Allocator>::expand ()
  {
!   Element_t **oentries;
!   Element_t **olimit;
!   Element_t **p;
!   Element_t **nentries;
    size_t nsize, osize, elts;
    unsigned int oindex, nindex;
  
*************** hash_table <Element, Hash, Equal, Remove
*** 491,497 ****
        nsize = osize;
      }
  
!   nentries = Allocator <Element *> ::data_alloc (nsize);
    gcc_assert (nentries != NULL);
    htab->entries = nentries;
    htab->size = nsize;
--- 457,463 ----
        nsize = osize;
      }
  
!   nentries = Allocator <Element_t *> ::data_alloc (nsize);
    gcc_assert (nentries != NULL);
    htab->entries = nentries;
    htab->size = nsize;
*************** hash_table <Element, Hash, Equal, Remove
*** 502,512 ****
    p = oentries;
    do
      {
!       Element *x = *p;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          {
!           Element **q = find_empty_slot_for_expand (Hash (x));
  
            *q = x;
          }
--- 468,478 ----
    p = oentries;
    do
      {
!       Element_t *x = *p;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          {
!           Element_t **q = find_empty_slot_for_expand (Element::hash (x));
  
            *q = x;
          }
*************** hash_table <Element, Hash, Equal, Remove
*** 515,521 ****
      }
    while (p < olimit);
  
!   Allocator <Element *> ::data_free (oentries);
  }
  
  
--- 481,487 ----
      }
    while (p < olimit);
  
!   Allocator <Element_t *> ::data_free (oentries);
  }
  
  
*************** hash_table <Element, Hash, Equal, Remove
*** 524,540 ****
     be used to insert or delete an element. */
  
  template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
! 	  template <typename Type> class Allocator>
! Element *
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::find_with_hash (Element *comparable, hashval_t hash)
  {
    hashval_t index, hash2;
    size_t size;
!   Element *entry;
  
    htab->searches++;
    size = htab->size;
--- 490,503 ----
     be used to insert or delete an element. */
  
  template <typename Element,
! 	  template <typename Type> class Allocator>
! typename Element::Element_t *
! hash_table <Element, Allocator>
! ::find_with_hash (Element_t *comparable, hashval_t hash)
  {
    hashval_t index, hash2;
    size_t size;
!   Element_t *entry;
  
    htab->searches++;
    size = htab->size;
*************** hash_table <Element, Hash, Equal, Remove
*** 542,548 ****
  
    entry = htab->entries[index];
    if (entry == HTAB_EMPTY_ENTRY
!       || (entry != HTAB_DELETED_ENTRY && Equal (entry, comparable)))
      return entry;
  
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
--- 505,511 ----
  
    entry = htab->entries[index];
    if (entry == HTAB_EMPTY_ENTRY
!       || (entry != HTAB_DELETED_ENTRY && Element::equal (entry, comparable)))
      return entry;
  
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
*************** hash_table <Element, Hash, Equal, Remove
*** 555,561 ****
  
        entry = htab->entries[index];
        if (entry == HTAB_EMPTY_ENTRY
!           || (entry != HTAB_DELETED_ENTRY && Equal (entry, comparable)))
          return entry;
      }
  }
--- 518,524 ----
  
        entry = htab->entries[index];
        if (entry == HTAB_EMPTY_ENTRY
!           || (entry != HTAB_DELETED_ENTRY && Element::equal (entry, comparable)))
          return entry;
      }
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 570,588 ****
     entry, NULL may be returned if memory allocation fails. */
  
  template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
! 	  template <typename Type> class Allocator>
! Element **
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::find_slot_with_hash (Element *comparable, hashval_t hash,
  		       enum insert_option insert)
  {
!   Element **first_deleted_slot;
    hashval_t index, hash2;
    size_t size;
!   Element *entry;
  
    size = htab->size;
    if (insert == INSERT && size * 3 <= htab->n_elements * 4)
--- 533,548 ----
     entry, NULL may be returned if memory allocation fails. */
  
  template <typename Element,
! 	  template <typename Type> class Allocator>
! typename Element::Element_t **
! hash_table <Element, Allocator>
! ::find_slot_with_hash (Element_t *comparable, hashval_t hash,
  		       enum insert_option insert)
  {
!   Element_t **first_deleted_slot;
    hashval_t index, hash2;
    size_t size;
!   Element_t *entry;
  
    size = htab->size;
    if (insert == INSERT && size * 3 <= htab->n_elements * 4)
*************** hash_table <Element, Hash, Equal, Remove
*** 601,607 ****
      goto empty_entry;
    else if (entry == HTAB_DELETED_ENTRY)
      first_deleted_slot = &htab->entries[index];
!   else if (Equal (entry, comparable))
      return &htab->entries[index];
        
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
--- 561,567 ----
      goto empty_entry;
    else if (entry == HTAB_DELETED_ENTRY)
      first_deleted_slot = &htab->entries[index];
!   else if (Element::equal (entry, comparable))
      return &htab->entries[index];
        
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
*************** hash_table <Element, Hash, Equal, Remove
*** 620,626 ****
  	  if (!first_deleted_slot)
  	    first_deleted_slot = &htab->entries[index];
  	}
!       else if (Equal (entry, comparable))
  	return &htab->entries[index];
      }
  
--- 580,586 ----
  	  if (!first_deleted_slot)
  	    first_deleted_slot = &htab->entries[index];
  	}
!       else if (Element::equal (entry, comparable))
  	return &htab->entries[index];
      }
  
*************** hash_table <Element, Hash, Equal, Remove
*** 631,637 ****
    if (first_deleted_slot)
      {
        htab->n_deleted--;
!       *first_deleted_slot = static_cast <Element *> (HTAB_EMPTY_ENTRY);
        return first_deleted_slot;
      }
  
--- 591,597 ----
    if (first_deleted_slot)
      {
        htab->n_deleted--;
!       *first_deleted_slot = static_cast <Element_t *> (HTAB_EMPTY_ENTRY);
        return first_deleted_slot;
      }
  
*************** hash_table <Element, Hash, Equal, Remove
*** 643,662 ****
  /* This function clears all entries in the given hash table.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::empty ()
  {
    size_t size = htab_size (htab);
!   Element **entries = htab->entries;
    int i;
  
    for (i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Remove (entries[i]);
  
    /* Instead of clearing megabyte, downsize the table.  */
    if (size > 1024*1024 / sizeof (PTR))
--- 603,619 ----
  /* This function clears all entries in the given hash table.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Allocator>::empty ()
  {
    size_t size = htab_size (htab);
!   Element_t **entries = htab->entries;
    int i;
  
    for (i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Element::remove (entries[i]);
  
    /* Instead of clearing megabyte, downsize the table.  */
    if (size > 1024*1024 / sizeof (PTR))
*************** hash_table <Element, Hash, Equal, Remove
*** 664,676 ****
        int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR));
        int nsize = prime_tab[nindex].prime;
  
!       Allocator <Element *> ::data_free (htab->entries);
!       htab->entries = Allocator <Element *> ::data_alloc (nsize);
        htab->size = nsize;
        htab->size_prime_index = nindex;
      }
    else
!     memset (entries, 0, size * sizeof (Element *));
    htab->n_deleted = 0;
    htab->n_elements = 0;
  }
--- 621,633 ----
        int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR));
        int nsize = prime_tab[nindex].prime;
  
!       Allocator <Element_t *> ::data_free (htab->entries);
!       htab->entries = Allocator <Element_t *> ::data_alloc (nsize);
        htab->size = nsize;
        htab->size_prime_index = nindex;
      }
    else
!     memset (entries, 0, size * sizeof (Element_t *));
    htab->n_deleted = 0;
    htab->n_elements = 0;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 681,699 ****
     again. */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::clear_slot (Element **slot)
  {
    if (slot < htab->entries || slot >= htab->entries + htab->size
        || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
      abort ();
  
!   Remove (*slot);
  
    *slot = HTAB_DELETED_ENTRY;
    htab->n_deleted++;
--- 638,653 ----
     again. */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Allocator>
! ::clear_slot (Element_t **slot)
  {
    if (slot < htab->entries || slot >= htab->entries + htab->size
        || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
      abort ();
  
!   Element::remove (*slot);
  
    *slot = HTAB_DELETED_ENTRY;
    htab->n_deleted++;
*************** hash_table <Element, Hash, Equal, Remove
*** 705,727 ****
     matching element in the hash table, this function does nothing. */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::remove_elt_with_hash (Element *comparable, hashval_t hash)
  {
!   Element **slot;
  
    slot = find_slot_with_hash (comparable, hash, NO_INSERT);
    if (*slot == HTAB_EMPTY_ENTRY)
      return;
  
!   Remove (*slot);
  
!   *slot = static_cast <Element *> (HTAB_DELETED_ENTRY);
    htab->n_deleted++;
  }
  
--- 659,678 ----
     matching element in the hash table, this function does nothing. */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Allocator>
! ::remove_elt_with_hash (Element_t *comparable, hashval_t hash)
  {
!   Element_t **slot;
  
    slot = find_slot_with_hash (comparable, hash, NO_INSERT);
    if (*slot == HTAB_EMPTY_ENTRY)
      return;
  
!   Element::remove (*slot);
  
!   *slot = static_cast <Element_t *> (HTAB_DELETED_ENTRY);
    htab->n_deleted++;
  }
  
*************** hash_table <Element, Hash, Equal, Remove
*** 731,755 ****
     ARGUMENT is passed as CALLBACK's second argument. */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (Element **slot, Argument argument)>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
  ::traverse_noresize (Argument argument)
  {
!   Element **slot;
!   Element **limit;
  
    slot = htab->entries;
    limit = slot + htab->size;
  
    do
      {
!       Element *x = *slot;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          if (! Callback (slot, argument))
--- 682,703 ----
     ARGUMENT is passed as CALLBACK's second argument. */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (typename Element::Element_t **slot, Argument argument)>
  void
! hash_table <Element, Allocator>
  ::traverse_noresize (Argument argument)
  {
!   Element_t **slot;
!   Element_t **limit;
  
    slot = htab->entries;
    limit = slot + htab->size;
  
    do
      {
!       Element_t *x = *slot;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          if (! Callback (slot, argument))
*************** hash_table <Element, Hash, Equal, Remove
*** 763,776 ****
     to improve effectivity of subsequent calls.  */
  
  template <typename Element,
- 	  hashval_t (*Hash) (const Element *candidate),
- 	  int (*Equal) (const Element *existing, const Element * candidate),
- 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (Element **slot, Argument argument)>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
  ::traverse (Argument argument)
  {
    size_t size = htab->size;
--- 711,721 ----
     to improve effectivity of subsequent calls.  */
  
  template <typename Element,
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (typename Element::Element_t **slot, Argument argument)>
  void
! hash_table <Element, Allocator>
  ::traverse (Argument argument)
  {
    size_t size = htab->size;
Index: gcc/coverage.c
===================================================================
*** gcc/coverage.c.orig	2012-08-15 15:39:34.000000000 +0200
--- gcc/coverage.c	2012-08-15 16:12:58.471636654 +0200
*************** get_gcov_unsigned_t (void)
*** 143,172 ****
    return lang_hooks.types.type_for_mode (mode, true);
  }
  
! inline hashval_t
! coverage_counts_entry_hash (const counts_entry_t *entry)
! {
!   return entry->ident * GCOV_COUNTERS + entry->ctr;
! }
! 
! inline int
! coverage_counts_entry_eq (const counts_entry_t *entry1,
!                           const counts_entry_t *entry2)
! {
!   return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
! }
! 
! inline void
! coverage_counts_entry_del (counts_entry_t *entry)
! {
!   free (entry->counts);
!   free (entry);
! }
  
  /* Hash table of count data.  */
! static hash_table <counts_entry_t, coverage_counts_entry_hash,
! 		   coverage_counts_entry_eq, coverage_counts_entry_del>
! 		  counts_hash;
  
  /* Read in the counts file, if available.  */
  
--- 143,172 ----
    return lang_hooks.types.type_for_mode (mode, true);
  }
  
! /* Hash functions for counts_entry.  */
! class counts_entry_hash {
! public:
!   typedef counts_entry_t Element_t;
!   static inline int equal (const counts_entry_t *entry1,
! 			   const counts_entry_t *entry2)
!   {
!     return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
!   }
!   static inline hashval_t
!   hash (const counts_entry_t *entry)
!   {
!     return entry->ident * GCOV_COUNTERS + entry->ctr;
!   }
!   static inline void
!   remove (counts_entry_t *entry)
!   {
!     free (entry->counts);
!     free (entry);
!   }
! };
  
  /* Hash table of count data.  */
! static hash_table <counts_entry_hash> counts_hash;
  
  /* Read in the counts file, if available.  */
  
Index: gcc/tree-ssa-ccp.c
===================================================================
*** gcc/tree-ssa-ccp.c.orig	2012-08-15 10:20:31.000000000 +0200
--- gcc/tree-ssa-ccp.c	2012-08-15 15:45:45.896693215 +0200
*************** evaluate_stmt (gimple stmt)
*** 1688,1697 ****
    return val;
  }
  
! typedef hash_table <gimple_statement_d, typed_pointer_hash<gimple_statement_d>,
! 		    typed_pointer_equal<gimple_statement_d>,
! 		    typed_null_remove<gimple_statement_d> >
! 		   gimple_htab;
  
  /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
     each matching BUILT_IN_STACK_RESTORE.  Mark visited phis in VISITED.  */
--- 1688,1694 ----
    return val;
  }
  
! typedef hash_table <pointer_hash <gimple_statement_d> > gimple_htab;
  
  /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
     each matching BUILT_IN_STACK_RESTORE.  Mark visited phis in VISITED.  */
Index: gcc/tree-ssa-coalesce.c
===================================================================
*** gcc/tree-ssa-coalesce.c.orig	2012-08-15 10:20:33.000000000 +0200
--- gcc/tree-ssa-coalesce.c	2012-08-15 16:14:56.051632549 +0200
*************** coalesce_partitions (var_map map, ssa_co
*** 1258,1278 ****
      }
  }
  
! /* Returns a hash code for N.  */
! 
! inline hashval_t
! hash_ssa_name_by_var (const_tree n)
! {
!   return (hashval_t) htab_hash_pointer (SSA_NAME_VAR (n));
! }
! 
! /* Returns nonzero if N1 and N2 are equal.  */
! 
! inline int
! eq_ssa_name_by_var (const_tree n1, const_tree n2)
! {
!   return SSA_NAME_VAR (n1) == SSA_NAME_VAR (n2);
! }
  
  /* Reduce the number of copies by coalescing variables in the function.  Return
     a partition map with the resulting coalesces.  */
--- 1258,1276 ----
      }
  }
  
! /* SSA_NAME_VAR hash.  */
! class ssa_name_var_hash : public typed_noop_remove <union tree_node> {
! public:
!   typedef union tree_node Element_t;
!   static inline hashval_t hash (const_tree n)
!   {
!     return DECL_UID (SSA_NAME_VAR (n));
!   }
!   static inline int equal (const_tree n1, const_tree n2)
!   {
!     return SSA_NAME_VAR (n1) == SSA_NAME_VAR (n2);
!   }
! };
  
  /* Reduce the number of copies by coalescing variables in the function.  Return
     a partition map with the resulting coalesces.  */
*************** coalesce_ssa_name (void)
*** 1286,1294 ****
    bitmap used_in_copies = BITMAP_ALLOC (NULL);
    var_map map;
    unsigned int i;
!   static hash_table <tree_node, hash_ssa_name_by_var, eq_ssa_name_by_var,
! 		     typed_null_remove<tree_node> >
! 		    ssa_name_hash;
  
    cl = create_coalesce_list ();
    map = create_outofssa_var_map (cl, used_in_copies);
--- 1284,1290 ----
    bitmap used_in_copies = BITMAP_ALLOC (NULL);
    var_map map;
    unsigned int i;
!   static hash_table <ssa_name_var_hash> ssa_name_hash;
  
    cl = create_coalesce_list ();
    map = create_outofssa_var_map (cl, used_in_copies);
Index: gcc/tree-ssa-pre.c
===================================================================
*** gcc/tree-ssa-pre.c.orig	2012-08-15 10:20:33.000000000 +0200
--- gcc/tree-ssa-pre.c	2012-08-15 16:16:11.339629977 +0200
*************** static unsigned int next_expression_id;
*** 229,237 ****
  DEF_VEC_P (pre_expr);
  DEF_VEC_ALLOC_P (pre_expr, heap);
  static VEC(pre_expr, heap) *expressions;
! static hash_table <pre_expr_d, ssa_pre_expr_hash, ssa_pre_expr_eq,
! 		   typed_null_remove <pre_expr_d> >
! 		  expression_to_id;
  static VEC(unsigned, heap) *name_to_id;
  
  /* Allocate an expression id for EXPR.  */
--- 229,247 ----
  DEF_VEC_P (pre_expr);
  DEF_VEC_ALLOC_P (pre_expr, heap);
  static VEC(pre_expr, heap) *expressions;
! struct pre_expr_hash : public typed_noop_remove <pre_expr_d> {
!   typedef pre_expr_d Element_t;
!   static inline hashval_t hash (const struct pre_expr_d *e)
!   {
!     return ssa_pre_expr_hash (e);
!   }
!   static inline int equal (const struct pre_expr_d *e1,
! 			   const struct pre_expr_d *e2)
!   {
!     return ssa_pre_expr_eq (e1, e2);
!   }
! };
! static hash_table <pre_expr_hash> expression_to_id;
  static VEC(unsigned, heap) *name_to_id;
  
  /* Allocate an expression id for EXPR.  */
*************** typedef struct expr_pred_trans_d
*** 500,537 ****
  } *expr_pred_trans_t;
  typedef const struct expr_pred_trans_d *const_expr_pred_trans_t;
  
- /* Return the hash value for a phi translation table entry.  */
- 
- inline hashval_t
- ssa_expr_pred_trans_hash (const expr_pred_trans_d *ve)
- {
-   return ve->hashcode;
- }
- 
- /* Return true if two phi translation table entries are the same.
-    P1 and P2 should point to the expr_pred_trans_t's to be compared.*/
- 
- inline int
- ssa_expr_pred_trans_eq (const expr_pred_trans_d *ve1,
- 			const expr_pred_trans_d *ve2)
- {
-   basic_block b1 = ve1->pred;
-   basic_block b2 = ve2->pred;
- 
-   /* If they are not translations for the same basic block, they can't
-      be equal.  */
-   if (b1 != b2)
-     return false;
-   return ssa_pre_expr_eq (ve1->e, ve2->e);
- }
- 
  /* The phi_translate_table caches phi translations for a given
     expression and predecessor.  */
! 
! static hash_table <expr_pred_trans_d, ssa_expr_pred_trans_hash,
! 		   ssa_expr_pred_trans_eq,
! 		   typed_free_remove <expr_pred_trans_d> >
! 		  phi_translate_table;
  
  /* Search in the phi translation table for the translation of
     expression E in basic block PRED.
--- 510,537 ----
  } *expr_pred_trans_t;
  typedef const struct expr_pred_trans_d *const_expr_pred_trans_t;
  
  /* The phi_translate_table caches phi translations for a given
     expression and predecessor.  */
! struct expr_pred_trans_hash : public typed_free_remove<expr_pred_trans_d>
! {
!   typedef expr_pred_trans_d Element_t;
!   static inline hashval_t hash (const Element_t *e)
!   {
!     return e->hashcode;
!   }
!   static inline int equal (const Element_t *ve1, const Element_t *ve2)
!   {
!     basic_block b1 = ve1->pred;
!     basic_block b2 = ve2->pred;
! 
!     /* If they are not translations for the same basic block, they can't
!        be equal.  */
!     if (b1 != b2)
!       return false;
!     return ssa_pre_expr_eq (ve1->e, ve2->e);
!   }
! };
! static hash_table <expr_pred_trans_hash> phi_translate_table;
  
  /* Search in the phi translation table for the translation of
     expression E in basic block PRED.
Index: gcc/tree-ssa-tail-merge.c
===================================================================
*** gcc/tree-ssa-tail-merge.c.orig	2012-08-15 10:20:26.000000000 +0200
--- gcc/tree-ssa-tail-merge.c	2012-08-15 16:24:46.219612235 +0200
*************** stmt_update_dep_bb (gimple stmt)
*** 415,422 ****
  
  /* Calculates hash value for same_succ VE.  */
  
! hashval_t
! ssa_same_succ_hash (const_same_succ e)
  {
    hashval_t hashval = bitmap_hash (e->succs);
    int flags;
--- 415,422 ----
  
  /* Calculates hash value for same_succ VE.  */
  
! static hashval_t
! same_succ_hash (const_same_succ e)
  {
    hashval_t hashval = bitmap_hash (e->succs);
    int flags;
*************** inverse_flags (const_same_succ e1, const
*** 511,520 ****
    return (f1a & mask) == (f2a & mask) && (f1b & mask) == (f2b & mask);
  }
  
  /* Compares SAME_SUCCs VE1 and VE2.  */
  
  int
! ssa_same_succ_equal (const_same_succ e1, const_same_succ e2)
  {
    unsigned int i, first1, first2;
    gimple_stmt_iterator gsi1, gsi2;
--- 511,572 ----
    return (f1a & mask) == (f2a & mask) && (f1b & mask) == (f2b & mask);
  }
  
+ /* Alloc and init a new SAME_SUCC.  */
+ 
+ static same_succ
+ same_succ_alloc (void)
+ {
+   same_succ same = XNEW (struct same_succ_def);
+ 
+   same->bbs = BITMAP_ALLOC (NULL);
+   same->succs = BITMAP_ALLOC (NULL);
+   same->inverse = BITMAP_ALLOC (NULL);
+   same->succ_flags = VEC_alloc (int, heap, 10);
+   same->in_worklist = false;
+ 
+   return same;
+ }
+ 
+ /* Delete same_succ VE.  */
+ 
+ static inline void
+ same_succ_delete (same_succ e)
+ {
+   BITMAP_FREE (e->bbs);
+   BITMAP_FREE (e->succs);
+   BITMAP_FREE (e->inverse);
+   VEC_free (int, heap, e->succ_flags);
+ 
+   XDELETE (e);
+ }
+ 
+ /* Reset same_succ SAME.  */
+ 
+ static void
+ same_succ_reset (same_succ same)
+ {
+   bitmap_clear (same->bbs);
+   bitmap_clear (same->succs);
+   bitmap_clear (same->inverse);
+   VEC_truncate (int, same->succ_flags, 0);
+ }
+ 
+ /* Hash table with all same_succ entries.  */
+ 
+ struct same_succ_hashtable {
+   typedef same_succ_def Element_t;
+   static inline hashval_t hash (const same_succ_def *e) { return e->hashval; }
+   static int equal (const_same_succ, const_same_succ);
+   static inline void remove (Element_t *e1)
+   {
+     same_succ_delete (e1);
+   }
+ };
+ 
  /* Compares SAME_SUCCs VE1 and VE2.  */
  
  int
! same_succ_hashtable::equal (const_same_succ e1, const_same_succ e2)
  {
    unsigned int i, first1, first2;
    gimple_stmt_iterator gsi1, gsi2;
*************** ssa_same_succ_equal (const_same_succ e1,
*** 568,618 ****
    return 1;
  }
  
! /* Alloc and init a new SAME_SUCC.  */
! 
! static same_succ
! same_succ_alloc (void)
! {
!   same_succ same = XNEW (struct same_succ_def);
! 
!   same->bbs = BITMAP_ALLOC (NULL);
!   same->succs = BITMAP_ALLOC (NULL);
!   same->inverse = BITMAP_ALLOC (NULL);
!   same->succ_flags = VEC_alloc (int, heap, 10);
!   same->in_worklist = false;
! 
!   return same;
! }
! 
! /* Delete same_succ VE.  */
! 
! inline void
! ssa_same_succ_delete (same_succ e)
! {
!   BITMAP_FREE (e->bbs);
!   BITMAP_FREE (e->succs);
!   BITMAP_FREE (e->inverse);
!   VEC_free (int, heap, e->succ_flags);
! 
!   XDELETE (e);
! }
! 
! /* Reset same_succ SAME.  */
! 
! static void
! same_succ_reset (same_succ same)
! {
!   bitmap_clear (same->bbs);
!   bitmap_clear (same->succs);
!   bitmap_clear (same->inverse);
!   VEC_truncate (int, same->succ_flags, 0);
! }
! 
! /* Hash table with all same_succ entries.  */
! 
! static hash_table <struct same_succ_def, ssa_same_succ_hash,
! 		   ssa_same_succ_equal, ssa_same_succ_delete>
! 		  same_succ_htab;
  
  /* Array that is used to store the edge flags for a successor.  */
  
--- 620,626 ----
    return 1;
  }
  
! static hash_table <same_succ_hashtable> same_succ_htab;
  
  /* Array that is used to store the edge flags for a successor.  */
  
*************** find_same_succ_bb (basic_block bb, same_
*** 692,698 ****
    EXECUTE_IF_SET_IN_BITMAP (same->succs, 0, j, bj)
      VEC_safe_push (int, heap, same->succ_flags, same_succ_edge_flags[j]);
  
!   same->hashval = ssa_same_succ_hash (same);
  
    slot = same_succ_htab.find_slot_with_hash (same, same->hashval, INSERT);
    if (*slot == NULL)
--- 700,706 ----
    EXECUTE_IF_SET_IN_BITMAP (same->succs, 0, j, bj)
      VEC_safe_push (int, heap, same->succ_flags, same_succ_edge_flags[j]);
  
!   same->hashval = same_succ_hash (same);
  
    slot = same_succ_htab.find_slot_with_hash (same, same->hashval, INSERT);
    if (*slot == NULL)
*************** find_same_succ (void)
*** 728,734 ****
  	same = same_succ_alloc ();
      }
  
!   ssa_same_succ_delete (same);
  }
  
  /* Initializes worklist administration.  */
--- 736,742 ----
  	same = same_succ_alloc ();
      }
  
!   same_succ_delete (same);
  }
  
  /* Initializes worklist administration.  */
*************** update_worklist (void)
*** 860,866 ****
        if (same == NULL)
  	same = same_succ_alloc ();
      }
!   ssa_same_succ_delete (same);
    bitmap_clear (deleted_bb_preds);
  }
  
--- 868,874 ----
        if (same == NULL)
  	same = same_succ_alloc ();
      }
!   same_succ_delete (same);
    bitmap_clear (deleted_bb_preds);
  }
  
Index: gcc/tree-ssa-threadupdate.c
===================================================================
*** gcc/tree-ssa-threadupdate.c.orig	2012-08-15 10:20:26.000000000 +0200
--- gcc/tree-ssa-threadupdate.c	2012-08-15 16:27:19.144606857 +0200
*************** create_block_for_threading (basic_block
*** 218,248 ****
  }
  
  /* Hashing and equality routines for our hash table.  */
- inline hashval_t
- ssa_redirection_data_hash (const struct redirection_data *p)
- {
-   edge e = p->outgoing_edge;
-   return e->dest->index;
- }
  
! inline int
! ssa_redirection_data_eq (const struct redirection_data *p1,
! 			 const struct redirection_data *p2)
  {
!   edge e1 = p1->outgoing_edge;
!   edge e2 = p2->outgoing_edge;
!   edge e3 = p1->intermediate_edge;
!   edge e4 = p2->intermediate_edge;
! 
!   return e1 == e2 && e3 == e4;
! }
  
  /* Main data structure to hold information for duplicates of BB.  */
  
! static hash_table <struct redirection_data, ssa_redirection_data_hash,
! 		   ssa_redirection_data_eq,
! 		   typed_free_remove<struct redirection_data> >
! 		  redirection_data;
  
  /* Given an outgoing edge E lookup and return its entry in our hash table.
  
--- 218,251 ----
  }
  
  /* Hashing and equality routines for our hash table.  */
  
! struct ssa_redirection_data_hash
!   : public typed_free_remove<struct redirection_data>
  {
!   typedef redirection_data Element_t;
!   static inline hashval_t
!   hash (const struct redirection_data *p)
!   {
!     edge e = p->outgoing_edge;
!     return e->dest->index;
!   }
! 
!   static inline int
!   equal (const struct redirection_data *p1,
!          const struct redirection_data *p2)
!   {
!     edge e1 = p1->outgoing_edge;
!     edge e2 = p2->outgoing_edge;
!     edge e3 = p1->intermediate_edge;
!     edge e4 = p2->intermediate_edge;
! 
!     return e1 == e2 && e3 == e4;
!   }
! };
  
  /* Main data structure to hold information for duplicates of BB.  */
  
! static hash_table <ssa_redirection_data_hash> redirection_data;
  
  /* Given an outgoing edge E lookup and return its entry in our hash table.
Richard Henderson - Aug. 15, 2012, 4:17 p.m.
On 2012-08-15 07:29, Richard Guenther wrote:
> +   typedef typename Element::Element_t Element_t;

Can we use something less ugly than Element_t?
Such as

  typedef typename Element::T T;

?  Given that this name is scoped anyway...

r~
Lawrence Crowl - Aug. 15, 2012, 9:57 p.m.
On 8/15/12, Richard Guenther <rguenther@suse.de> wrote:
> On Wed, 15 Aug 2012, Michael Matz wrote:
> > On Wed, 15 Aug 2012, Richard Guenther wrote:
> > > Like the following, only the coverage.c use is converted.
> > > I've never seen template function arguments anywhere and
> > > having to repeat them all
> > >
> > > over the place is really really ugly (yes, even if only in
> > > the implementation).
> > >
> > > This goes with static member functions and not wrapping any
> > > data. It goes away with the requirement of having externally
> > > visible global functions for the hash/compare functions as well
> > > (which was ugly anyway).
> >
> > Well, it looks nicer than what's there currently.  As the
> > element functions now are scoped and normal member functions,
> > they should be named with lower case characters of course.  I do
> > like that the hash table would then only have one real template
> > argument; the Allocator, well, no better idea comes to my mind.
>
> Yeah.  Updated patch below, all users converted.  I probably
> missed to revert some of the globalizations of hash/compare fns.

Your conversion is a better abstraction, and something I'd wanted
to get to eventually, so I support your conversion.

BTW, the conding conventions say to put member function definitions
out of line.
Lawrence Crowl - Aug. 15, 2012, 9:58 p.m.
On 8/15/12, Richard Henderson <rth@redhat.com> wrote:
> On 2012-08-15 07:29, Richard Guenther wrote:
>> +   typedef typename Element::Element_t Element_t;
>
> Can we use something less ugly than Element_t?
> Such as
>
>   typedef typename Element::T T;
>
> ?  Given that this name is scoped anyway...

I do not much like _t names either.
Ian Taylor - Aug. 15, 2012, 10:26 p.m.
On Wed, Aug 15, 2012 at 2:58 PM, Lawrence Crowl <crowl@google.com> wrote:
>
> I do not much like _t names either.

Also, names ending in _t are reserved by POSIX if you #include
<sys/types.h>.  Though that may only apply to global names, not to
types defined in classes or namespaces.

Ian
Richard Guenther - Aug. 16, 2012, 9:19 a.m.
On Wed, 15 Aug 2012, Lawrence Crowl wrote:

> On 8/15/12, Richard Henderson <rth@redhat.com> wrote:
> > On 2012-08-15 07:29, Richard Guenther wrote:
> >> +   typedef typename Element::Element_t Element_t;
> >
> > Can we use something less ugly than Element_t?
> > Such as
> >
> >   typedef typename Element::T T;
> >
> > ?  Given that this name is scoped anyway...
> 
> I do not much like _t names either.

The following is what I'm testing now, it also integrates the
hashtable support functions and typedef within the existing local
data types which is IMHO cleaner.  (it also shows we can do with
a janitorial cleanup replacing typedef struct foo_d {} foo; with
struct foo {}; and the likes)

Bootstrap and regtest ongoing on x86_64-unknown-linux-gnu, ok?

Thanks,
Richard.

2012-08-16  Richard Guenther  <rguenther@suse.de>

	* hash-table.h (class hash_table): Use a descriptor template
	argument instead of decomposed element type and support
	functions.
	(struct pointer_hash): New generic typed pointer-hash.
	(struct typed_free_remove, struct typed_noop_remove): Generic
	hash_table support pieces.
	* coverage.c (struct counts_entry): Add hash_table support
	members.
	* tree-ssa-ccp.c (gimple_htab): Use pointer_hash.
	* tree-ssa-coalesce.c (struct ssa_name_var_hash): New generic
	SSA name by SSA_NAME_VAR hash.
	(coalesce_ssa_name): Use it.
	* tree-ssa-pre.c (struct pre_expr_d): Add hash_table support.
	(expression_to_id): Adjust.
	(struct expr_pred_trans_d): Add hash_table support.
	(phi_translate_table): Adjust.
	(phi_trans_lookup): Likewise.
	(phi_trans_add): Likewise.
	(do_regular_insertion): Likewise.
	* tree-ssa-tail-merge.c (struct same_succ_def): Add hash_table
	support.
	(same_succ_htab): Adjust.
	(find_same_succ_bb): Likewise.
	(find_same_succ): Likewise.
	(update_worklist): Likewise.
	* tree-ssa-threadupdate.c (struct redirection_data): Add hash_table
	support.
	(redirection_data): Adjust.

Index: gcc/hash-table.h
===================================================================
*** gcc/hash-table.h.orig	2012-08-16 10:33:59.000000000 +0200
--- gcc/hash-table.h	2012-08-16 11:08:36.311277498 +0200
*************** xcallocator <Type>::data_free (Type *mem
*** 83,127 ****
  }
  
  
! /* A common function for hashing a CANDIDATE typed pointer.  */
  
  template <typename Element>
! inline hashval_t
! typed_pointer_hash (const Element *candidate)
  {
!   /* This is a really poor hash function, but it is what the current code uses,
!      so I am reusing it to avoid an additional axis in testing.  */
!   return (hashval_t) ((intptr_t)candidate >> 3);
! }
! 
  
! /* A common function for comparing an EXISTING and CANDIDATE typed pointers
!    for equality. */
  
  template <typename Element>
! inline int
! typed_pointer_equal (const Element *existing, const Element * candidate)
  {
!   return existing == candidate;
! }
  
  
! /* A common function for doing nothing on removing a RETIRED slot.  */
  
  template <typename Element>
! inline void
! typed_null_remove (Element *retired ATTRIBUTE_UNUSED)
  {
! }
  
  
! /* A common function for using free on removing a RETIRED slot.  */
  
  template <typename Element>
! inline void
! typed_free_remove (Element *retired)
  {
!   free (retired);
  }
  
  
--- 83,134 ----
  }
  
  
! /* Remove method dispatching to free.  */
  
  template <typename Element>
! struct typed_free_remove
  {
!   static inline void remove (Element *p) { free (p); }
! };
  
! /* No-op remove method.  */
  
  template <typename Element>
! struct typed_noop_remove
  {
!   static inline void remove (Element *) {}
! };
  
  
! /* Pointer hash with a no-op remove method.  */
  
  template <typename Element>
! struct pointer_hash : typed_noop_remove <Element>
  {
!   typedef Element T;
  
+   static inline hashval_t
+   hash (const T *);
  
!   static inline int
!   equal (const T *existing, const T * candidate);
! };
  
  template <typename Element>
! inline hashval_t
! pointer_hash<Element>::hash (const T *candidate)
  {
!   /* This is a really poor hash function, but it is what the current code uses,
!      so I am reusing it to avoid an additional axis in testing.  */
!   return (hashval_t) ((intptr_t)candidate >> 3);
! }
! 
! template <typename Element>
! inline int
! pointer_hash<Element>::equal (const T *existing,
! 			      const T *candidate)
! {
!   return existing == candidate;
  }
  
  
*************** extern hashval_t hash_table_mod2 (hashva
*** 147,157 ****
  
  /* Internal implementation type.  */
  
! template <typename Element>
  struct hash_table_control
  {
    /* Table itself.  */
!   Element **entries;
  
    /* Current size (in entries) of the hash table.  */
    size_t size;
--- 154,164 ----
  
  /* Internal implementation type.  */
  
! template <typename T>
  struct hash_table_control
  {
    /* Table itself.  */
!   T **entries;
  
    /* Current size (in entries) of the hash table.  */
    size_t size;
*************** struct hash_table_control
*** 180,194 ****
  
     The table stores elements of type Element.
  
!    It hashes elements with the Hash function.
       The table currently works with relatively weak hash functions.
       Use typed_pointer_hash <Element> when hashing pointers instead of objects.
  
!    It compares elements with the Equal function.
       Two elements with the same hash may not be equal.
       Use typed_pointer_equal <Element> when hashing pointers instead of objects.
  
!    It removes elements with the Remove function.
       This feature is useful for freeing memory.
       Use typed_null_remove <Element> when not freeing objects.
       Use typed_free_remove <Element> when doing a simple object free.
--- 187,201 ----
  
     The table stores elements of type Element.
  
!    It hashes elements with the hash function.
       The table currently works with relatively weak hash functions.
       Use typed_pointer_hash <Element> when hashing pointers instead of objects.
  
!    It compares elements with the equal function.
       Two elements with the same hash may not be equal.
       Use typed_pointer_equal <Element> when hashing pointers instead of objects.
  
!    It removes elements with the remove function.
       This feature is useful for freeing memory.
       Use typed_null_remove <Element> when not freeing objects.
       Use typed_free_remove <Element> when doing a simple object free.
*************** struct hash_table_control
*** 198,256 ****
  
  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator = xcallocator>
  class hash_table
  {
  
  private:
  
!   hash_table_control <Element> *htab;
! 
!   Element **find_empty_slot_for_expand (hashval_t hash);
    void expand ();
  
  public:
- 
    hash_table ();
    void create (size_t initial_slots);
    bool is_created ();
    void dispose ();
!   Element *find (Element *comparable);
!   Element *find_with_hash (Element *comparable, hashval_t hash);
!   Element **find_slot (Element *comparable, enum insert_option insert);
!   Element **find_slot_with_hash (Element *comparable, hashval_t hash,
! 				 enum insert_option insert);
    void empty ();
!   void clear_slot (Element **slot);
!   void remove_elt (Element *comparable);
!   void remove_elt_with_hash (Element *comparable, hashval_t hash);
    size_t size();
    size_t elements();
    double collisions();
  
    template <typename Argument,
! 	    int (*Callback) (Element **slot, Argument argument)>
    void traverse_noresize (Argument argument);
  
    template <typename Argument,
! 	    int (*Callback) (Element **slot, Argument argument)>
    void traverse (Argument argument);
  };
  
  
  /* Construct the hash table.  The only useful operation next is create.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline
! hash_table <Element, Hash, Equal, Remove, Allocator>::hash_table ()
  : htab (NULL)
  {
  }
--- 205,257 ----
  
  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator = xcallocator>
  class hash_table
  {
+ public:
+   typedef typename Descr::T T;
  
  private:
+   hash_table_control <T> *htab;
  
!   T **find_empty_slot_for_expand (hashval_t hash);
    void expand ();
  
  public:
    hash_table ();
    void create (size_t initial_slots);
    bool is_created ();
    void dispose ();
!   T *find (T *comparable);
!   T *find_with_hash (T *comparable, hashval_t hash);
!   T **find_slot (T *comparable, enum insert_option insert);
!   T **find_slot_with_hash (T *comparable, hashval_t hash,
! 				   enum insert_option insert);
    void empty ();
!   void clear_slot (T **slot);
!   void remove_elt (T *comparable);
!   void remove_elt_with_hash (T *comparable, hashval_t hash);
    size_t size();
    size_t elements();
    double collisions();
  
    template <typename Argument,
! 	    int (*Callback) (T **slot, Argument argument)>
    void traverse_noresize (Argument argument);
  
    template <typename Argument,
! 	    int (*Callback) (T **slot, Argument argument)>
    void traverse (Argument argument);
  };
  
  
  /* Construct the hash table.  The only useful operation next is create.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  inline
! hash_table <Descr, Allocator>::hash_table ()
  : htab (NULL)
  {
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 258,270 ****
  
  /* See if the table has been created, as opposed to constructed.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline bool
! hash_table <Element, Hash, Equal, Remove, Allocator>::is_created ()
  {
    return htab != NULL;
  }
--- 259,268 ----
  
  /* See if the table has been created, as opposed to constructed.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  inline bool
! hash_table <Descr, Allocator>::is_created ()
  {
    return htab != NULL;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 272,328 ****
  
  /* Like find_with_hash, but compute the hash value from the element.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
! inline Element *
! hash_table <Element, Hash, Equal, Remove, Allocator>::find (Element *comparable)
  {
!   return find_with_hash (comparable, Hash (comparable));
  }
  
  
  /* Like find_slot_with_hash, but compute the hash value from the element.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
! 	  template <typename Type> class Allocator>
! inline Element **
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::find_slot (Element *comparable, enum insert_option insert)
  {
!   return find_slot_with_hash (comparable, Hash (comparable), insert);
  }
  
  
  /* Like remove_elt_with_hash, but compute the hash value from the element.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline void
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::remove_elt (Element *comparable)
  {
!   remove_elt_with_hash (comparable, Hash (comparable));
  }
  
  
  /* Return the current size of this hash table.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Element, Hash, Equal, Remove, Allocator>::size()
  {
    return htab->size;
  }
--- 270,314 ----
  
  /* Like find_with_hash, but compute the hash value from the element.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
! inline typename Descr::T *
! hash_table <Descr, Allocator>::find (T *comparable)
  {
!   return find_with_hash (comparable, Descr::hash (comparable));
  }
  
  
  /* Like find_slot_with_hash, but compute the hash value from the element.  */
  
! template <typename Descr,
! 	  template <typename Type> class Allocator>
! inline typename Descr::T **
! hash_table <Descr, Allocator>
! ::find_slot (T *comparable, enum insert_option insert)
  {
!   return find_slot_with_hash (comparable, Descr::hash (comparable), insert);
  }
  
  
  /* Like remove_elt_with_hash, but compute the hash value from the element.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  inline void
! hash_table <Descr, Allocator>
! ::remove_elt (T *comparable)
  {
!   remove_elt_with_hash (comparable, Descr::hash (comparable));
  }
  
  
  /* Return the current size of this hash table.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Descr, Allocator>::size()
  {
    return htab->size;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 330,342 ****
  
  /* Return the current number of elements in this hash table. */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Element, Hash, Equal, Remove, Allocator>::elements()
  {
    return htab->n_elements - htab->n_deleted;
  }
--- 316,325 ----
  
  /* Return the current number of elements in this hash table. */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  inline size_t
! hash_table <Descr, Allocator>::elements()
  {
    return htab->n_elements - htab->n_deleted;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 345,357 ****
    /* Return the fraction of fixed collisions during all work with given
       hash table. */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  inline double
! hash_table <Element, Hash, Equal, Remove, Allocator>::collisions()
  {
    if (htab->searches == 0)
      return 0.0;
--- 328,337 ----
    /* Return the fraction of fixed collisions during all work with given
       hash table. */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  inline double
! hash_table <Descr, Allocator>::collisions()
  {
    if (htab->searches == 0)
      return 0.0;
*************** hash_table <Element, Hash, Equal, Remove
*** 362,383 ****
  
  /* Create a hash table with at least the given number of INITIAL_SLOTS.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::create (size_t size)
  {
    unsigned int size_prime_index;
  
    size_prime_index = hash_table_higher_prime_index (size);
    size = prime_tab[size_prime_index].prime;
  
!   htab = Allocator <hash_table_control <Element> > ::control_alloc (1);
    gcc_assert (htab != NULL);
!   htab->entries = Allocator <Element*> ::data_alloc (size);
    gcc_assert (htab->entries != NULL);
    htab->size = size;
    htab->size_prime_index = size_prime_index;
--- 342,360 ----
  
  /* Create a hash table with at least the given number of INITIAL_SLOTS.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  void
! hash_table <Descr, Allocator>::create (size_t size)
  {
    unsigned int size_prime_index;
  
    size_prime_index = hash_table_higher_prime_index (size);
    size = prime_tab[size_prime_index].prime;
  
!   htab = Allocator <hash_table_control <T> > ::control_alloc (1);
    gcc_assert (htab != NULL);
!   htab->entries = Allocator <T*> ::data_alloc (size);
    gcc_assert (htab->entries != NULL);
    htab->size = size;
    htab->size_prime_index = size_prime_index;
*************** hash_table <Element, Hash, Equal, Remove
*** 387,432 ****
  /* Dispose of a hash table.  Free all memory and return this hash table to
     the non-created state.  Naturally the hash table must already exist.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::dispose ()
  {
    size_t size = htab->size;
!   Element **entries = htab->entries;
  
    for (int i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Remove (entries[i]);
  
!   Allocator <Element *> ::data_free (entries);
!   Allocator <hash_table_control <Element> > ::control_free (htab);
    htab = NULL;
  }
  
  
  /* Similar to find_slot, but without several unwanted side effects:
!     - Does not call Equal when it finds an existing entry.
      - Does not change the count of elements/searches/collisions in the
        hash table.
     This function also assumes there are no deleted entries in the table.
     HASH is the hash value for the element to be inserted.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
! Element **
! hash_table <Element, Hash, Equal, Remove, Allocator>
  ::find_empty_slot_for_expand (hashval_t hash)
  {
    hashval_t index = hash_table_mod1 (hash, htab->size_prime_index);
    size_t size = htab->size;
!   Element **slot = htab->entries + index;
    hashval_t hash2;
  
    if (*slot == HTAB_EMPTY_ENTRY)
--- 364,403 ----
  /* Dispose of a hash table.  Free all memory and return this hash table to
     the non-created state.  Naturally the hash table must already exist.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  void
! hash_table <Descr, Allocator>::dispose ()
  {
    size_t size = htab->size;
!   T **entries = htab->entries;
  
    for (int i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Descr::remove (entries[i]);
  
!   Allocator <T *> ::data_free (entries);
!   Allocator <hash_table_control <T> > ::control_free (htab);
    htab = NULL;
  }
  
  
  /* Similar to find_slot, but without several unwanted side effects:
!     - Does not call equal when it finds an existing entry.
      - Does not change the count of elements/searches/collisions in the
        hash table.
     This function also assumes there are no deleted entries in the table.
     HASH is the hash value for the element to be inserted.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
! typename Descr::T **
! hash_table <Descr, Allocator>
  ::find_empty_slot_for_expand (hashval_t hash)
  {
    hashval_t index = hash_table_mod1 (hash, htab->size_prime_index);
    size_t size = htab->size;
!   T **slot = htab->entries + index;
    hashval_t hash2;
  
    if (*slot == HTAB_EMPTY_ENTRY)
*************** hash_table <Element, Hash, Equal, Remove
*** 457,474 ****
     table entries is changed.  If memory allocation fails, this function
     will abort.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::expand ()
  {
!   Element **oentries;
!   Element **olimit;
!   Element **p;
!   Element **nentries;
    size_t nsize, osize, elts;
    unsigned int oindex, nindex;
  
--- 428,442 ----
     table entries is changed.  If memory allocation fails, this function
     will abort.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  void
! hash_table <Descr, Allocator>::expand ()
  {
!   T **oentries;
!   T **olimit;
!   T **p;
!   T **nentries;
    size_t nsize, osize, elts;
    unsigned int oindex, nindex;
  
*************** hash_table <Element, Hash, Equal, Remove
*** 491,497 ****
        nsize = osize;
      }
  
!   nentries = Allocator <Element *> ::data_alloc (nsize);
    gcc_assert (nentries != NULL);
    htab->entries = nentries;
    htab->size = nsize;
--- 459,465 ----
        nsize = osize;
      }
  
!   nentries = Allocator <T *> ::data_alloc (nsize);
    gcc_assert (nentries != NULL);
    htab->entries = nentries;
    htab->size = nsize;
*************** hash_table <Element, Hash, Equal, Remove
*** 502,512 ****
    p = oentries;
    do
      {
!       Element *x = *p;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          {
!           Element **q = find_empty_slot_for_expand (Hash (x));
  
            *q = x;
          }
--- 470,480 ----
    p = oentries;
    do
      {
!       T *x = *p;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          {
!           T **q = find_empty_slot_for_expand (Descr::hash (x));
  
            *q = x;
          }
*************** hash_table <Element, Hash, Equal, Remove
*** 515,521 ****
      }
    while (p < olimit);
  
!   Allocator <Element *> ::data_free (oentries);
  }
  
  
--- 483,489 ----
      }
    while (p < olimit);
  
!   Allocator <T *> ::data_free (oentries);
  }
  
  
*************** hash_table <Element, Hash, Equal, Remove
*** 523,540 ****
     COMPARABLE element starting with the given HASH value.  It cannot
     be used to insert or delete an element. */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
! 	  template <typename Type> class Allocator>
! Element *
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::find_with_hash (Element *comparable, hashval_t hash)
  {
    hashval_t index, hash2;
    size_t size;
!   Element *entry;
  
    htab->searches++;
    size = htab->size;
--- 491,505 ----
     COMPARABLE element starting with the given HASH value.  It cannot
     be used to insert or delete an element. */
  
! template <typename Descr,
! 	  template <typename Type> class Allocator>
! typename Descr::T *
! hash_table <Descr, Allocator>
! ::find_with_hash (T *comparable, hashval_t hash)
  {
    hashval_t index, hash2;
    size_t size;
!   T *entry;
  
    htab->searches++;
    size = htab->size;
*************** hash_table <Element, Hash, Equal, Remove
*** 542,548 ****
  
    entry = htab->entries[index];
    if (entry == HTAB_EMPTY_ENTRY
!       || (entry != HTAB_DELETED_ENTRY && Equal (entry, comparable)))
      return entry;
  
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
--- 507,513 ----
  
    entry = htab->entries[index];
    if (entry == HTAB_EMPTY_ENTRY
!       || (entry != HTAB_DELETED_ENTRY && Descr::equal (entry, comparable)))
      return entry;
  
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
*************** hash_table <Element, Hash, Equal, Remove
*** 555,561 ****
  
        entry = htab->entries[index];
        if (entry == HTAB_EMPTY_ENTRY
!           || (entry != HTAB_DELETED_ENTRY && Equal (entry, comparable)))
          return entry;
      }
  }
--- 520,526 ----
  
        entry = htab->entries[index];
        if (entry == HTAB_EMPTY_ENTRY
!           || (entry != HTAB_DELETED_ENTRY && Descr::equal (entry, comparable)))
          return entry;
      }
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 569,588 ****
     write the value you want into the returned slot.  When inserting an
     entry, NULL may be returned if memory allocation fails. */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
! 	  template <typename Type> class Allocator>
! Element **
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::find_slot_with_hash (Element *comparable, hashval_t hash,
  		       enum insert_option insert)
  {
!   Element **first_deleted_slot;
    hashval_t index, hash2;
    size_t size;
!   Element *entry;
  
    size = htab->size;
    if (insert == INSERT && size * 3 <= htab->n_elements * 4)
--- 534,550 ----
     write the value you want into the returned slot.  When inserting an
     entry, NULL may be returned if memory allocation fails. */
  
! template <typename Descr,
! 	  template <typename Type> class Allocator>
! typename Descr::T **
! hash_table <Descr, Allocator>
! ::find_slot_with_hash (T *comparable, hashval_t hash,
  		       enum insert_option insert)
  {
!   T **first_deleted_slot;
    hashval_t index, hash2;
    size_t size;
!   T *entry;
  
    size = htab->size;
    if (insert == INSERT && size * 3 <= htab->n_elements * 4)
*************** hash_table <Element, Hash, Equal, Remove
*** 601,607 ****
      goto empty_entry;
    else if (entry == HTAB_DELETED_ENTRY)
      first_deleted_slot = &htab->entries[index];
!   else if (Equal (entry, comparable))
      return &htab->entries[index];
        
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
--- 563,569 ----
      goto empty_entry;
    else if (entry == HTAB_DELETED_ENTRY)
      first_deleted_slot = &htab->entries[index];
!   else if (Descr::equal (entry, comparable))
      return &htab->entries[index];
        
    hash2 = hash_table_mod2 (hash, htab->size_prime_index);
*************** hash_table <Element, Hash, Equal, Remove
*** 620,626 ****
  	  if (!first_deleted_slot)
  	    first_deleted_slot = &htab->entries[index];
  	}
!       else if (Equal (entry, comparable))
  	return &htab->entries[index];
      }
  
--- 582,588 ----
  	  if (!first_deleted_slot)
  	    first_deleted_slot = &htab->entries[index];
  	}
!       else if (Descr::equal (entry, comparable))
  	return &htab->entries[index];
      }
  
*************** hash_table <Element, Hash, Equal, Remove
*** 631,637 ****
    if (first_deleted_slot)
      {
        htab->n_deleted--;
!       *first_deleted_slot = static_cast <Element *> (HTAB_EMPTY_ENTRY);
        return first_deleted_slot;
      }
  
--- 593,599 ----
    if (first_deleted_slot)
      {
        htab->n_deleted--;
!       *first_deleted_slot = static_cast <T *> (HTAB_EMPTY_ENTRY);
        return first_deleted_slot;
      }
  
*************** hash_table <Element, Hash, Equal, Remove
*** 642,662 ****
  
  /* This function clears all entries in the given hash table.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>::empty ()
  {
    size_t size = htab_size (htab);
!   Element **entries = htab->entries;
    int i;
  
    for (i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Remove (entries[i]);
  
    /* Instead of clearing megabyte, downsize the table.  */
    if (size > 1024*1024 / sizeof (PTR))
--- 604,621 ----
  
  /* This function clears all entries in the given hash table.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  void
! hash_table <Descr, Allocator>::empty ()
  {
    size_t size = htab_size (htab);
!   T **entries = htab->entries;
    int i;
  
    for (i = size - 1; i >= 0; i--)
      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
!       Descr::remove (entries[i]);
  
    /* Instead of clearing megabyte, downsize the table.  */
    if (size > 1024*1024 / sizeof (PTR))
*************** hash_table <Element, Hash, Equal, Remove
*** 664,676 ****
        int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR));
        int nsize = prime_tab[nindex].prime;
  
!       Allocator <Element *> ::data_free (htab->entries);
!       htab->entries = Allocator <Element *> ::data_alloc (nsize);
        htab->size = nsize;
        htab->size_prime_index = nindex;
      }
    else
!     memset (entries, 0, size * sizeof (Element *));
    htab->n_deleted = 0;
    htab->n_elements = 0;
  }
--- 623,635 ----
        int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR));
        int nsize = prime_tab[nindex].prime;
  
!       Allocator <T *> ::data_free (htab->entries);
!       htab->entries = Allocator <T *> ::data_alloc (nsize);
        htab->size = nsize;
        htab->size_prime_index = nindex;
      }
    else
!     memset (entries, 0, size * sizeof (T *));
    htab->n_deleted = 0;
    htab->n_elements = 0;
  }
*************** hash_table <Element, Hash, Equal, Remove
*** 680,699 ****
     useful when you've already done the lookup and don't want to do it
     again. */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::clear_slot (Element **slot)
  {
    if (slot < htab->entries || slot >= htab->entries + htab->size
        || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
      abort ();
  
!   Remove (*slot);
  
    *slot = HTAB_DELETED_ENTRY;
    htab->n_deleted++;
--- 639,655 ----
     useful when you've already done the lookup and don't want to do it
     again. */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  void
! hash_table <Descr, Allocator>
! ::clear_slot (T **slot)
  {
    if (slot < htab->entries || slot >= htab->entries + htab->size
        || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
      abort ();
  
!   Descr::remove (*slot);
  
    *slot = HTAB_DELETED_ENTRY;
    htab->n_deleted++;
*************** hash_table <Element, Hash, Equal, Remove
*** 704,727 ****
     from hash table starting with the given HASH.  If there is no
     matching element in the hash table, this function does nothing. */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
! ::remove_elt_with_hash (Element *comparable, hashval_t hash)
  {
!   Element **slot;
  
    slot = find_slot_with_hash (comparable, hash, NO_INSERT);
    if (*slot == HTAB_EMPTY_ENTRY)
      return;
  
!   Remove (*slot);
  
!   *slot = static_cast <Element *> (HTAB_DELETED_ENTRY);
    htab->n_deleted++;
  }
  
--- 660,680 ----
     from hash table starting with the given HASH.  If there is no
     matching element in the hash table, this function does nothing. */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  void
! hash_table <Descr, Allocator>
! ::remove_elt_with_hash (T *comparable, hashval_t hash)
  {
!   T **slot;
  
    slot = find_slot_with_hash (comparable, hash, NO_INSERT);
    if (*slot == HTAB_EMPTY_ENTRY)
      return;
  
!   Descr::remove (*slot);
  
!   *slot = static_cast <T *> (HTAB_DELETED_ENTRY);
    htab->n_deleted++;
  }
  
*************** hash_table <Element, Hash, Equal, Remove
*** 730,755 ****
     each live entry.  If CALLBACK returns false, the iteration stops.
     ARGUMENT is passed as CALLBACK's second argument. */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (Element **slot, Argument argument)>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
  ::traverse_noresize (Argument argument)
  {
!   Element **slot;
!   Element **limit;
  
    slot = htab->entries;
    limit = slot + htab->size;
  
    do
      {
!       Element *x = *slot;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          if (! Callback (slot, argument))
--- 683,705 ----
     each live entry.  If CALLBACK returns false, the iteration stops.
     ARGUMENT is passed as CALLBACK's second argument. */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (typename Descr::T **slot, Argument argument)>
  void
! hash_table <Descr, Allocator>
  ::traverse_noresize (Argument argument)
  {
!   T **slot;
!   T **limit;
  
    slot = htab->entries;
    limit = slot + htab->size;
  
    do
      {
!       T *x = *slot;
  
        if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
          if (! Callback (slot, argument))
*************** hash_table <Element, Hash, Equal, Remove
*** 762,776 ****
  /* Like traverse_noresize, but does resize the table when it is too empty
     to improve effectivity of subsequent calls.  */
  
! template <typename Element,
! 	  hashval_t (*Hash) (const Element *candidate),
! 	  int (*Equal) (const Element *existing, const Element * candidate),
! 	  void (*Remove) (Element *retired),
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (Element **slot, Argument argument)>
  void
! hash_table <Element, Hash, Equal, Remove, Allocator>
  ::traverse (Argument argument)
  {
    size_t size = htab->size;
--- 712,723 ----
  /* Like traverse_noresize, but does resize the table when it is too empty
     to improve effectivity of subsequent calls.  */
  
! template <typename Descr,
  	  template <typename Type> class Allocator>
  template <typename Argument,
! 	  int (*Callback) (typename Descr::T **slot, Argument argument)>
  void
! hash_table <Descr, Allocator>
  ::traverse (Argument argument)
  {
    size_t size = htab->size;
Index: gcc/coverage.c
===================================================================
*** gcc/coverage.c.orig	2012-08-16 10:33:59.000000000 +0200
--- gcc/coverage.c	2012-08-16 10:54:30.986306770 +0200
*************** typedef struct counts_entry
*** 77,82 ****
--- 77,88 ----
    unsigned cfg_checksum;
    gcov_type *counts;
    struct gcov_ctr_summary summary;
+ 
+   /* hash_table support.  */
+   typedef counts_entry T;
+   static inline hashval_t hash (const counts_entry *);
+   static int equal (const counts_entry *, const counts_entry *);
+   static void remove (counts_entry *);
  } counts_entry_t;
  
  static GTY(()) struct coverage_data *functions_head = 0;
*************** get_gcov_unsigned_t (void)
*** 144,172 ****
  }
  
  inline hashval_t
! coverage_counts_entry_hash (const counts_entry_t *entry)
  {
    return entry->ident * GCOV_COUNTERS + entry->ctr;
  }
  
  inline int
! coverage_counts_entry_eq (const counts_entry_t *entry1,
!                           const counts_entry_t *entry2)
  {
    return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
  }
  
  inline void
! coverage_counts_entry_del (counts_entry_t *entry)
  {
    free (entry->counts);
    free (entry);
  }
  
  /* Hash table of count data.  */
! static hash_table <counts_entry_t, coverage_counts_entry_hash,
! 		   coverage_counts_entry_eq, coverage_counts_entry_del>
! 		  counts_hash;
  
  /* Read in the counts file, if available.  */
  
--- 150,176 ----
  }
  
  inline hashval_t
! counts_entry::hash (const counts_entry_t *entry)
  {
    return entry->ident * GCOV_COUNTERS + entry->ctr;
  }
  
  inline int
! counts_entry::equal (const counts_entry_t *entry1,
! 		     const counts_entry_t *entry2)
  {
    return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
  }
  
  inline void
! counts_entry::remove (counts_entry_t *entry)
  {
    free (entry->counts);
    free (entry);
  }
  
  /* Hash table of count data.  */
! static hash_table <counts_entry> counts_hash;
  
  /* Read in the counts file, if available.  */
  
Index: gcc/tree-ssa-ccp.c
===================================================================
*** gcc/tree-ssa-ccp.c.orig	2012-08-16 10:33:59.000000000 +0200
--- gcc/tree-ssa-ccp.c	2012-08-16 10:34:56.175347440 +0200
*************** evaluate_stmt (gimple stmt)
*** 1688,1697 ****
    return val;
  }
  
! typedef hash_table <gimple_statement_d, typed_pointer_hash<gimple_statement_d>,
! 		    typed_pointer_equal<gimple_statement_d>,
! 		    typed_null_remove<gimple_statement_d> >
! 		   gimple_htab;
  
  /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
     each matching BUILT_IN_STACK_RESTORE.  Mark visited phis in VISITED.  */
--- 1688,1694 ----
    return val;
  }
  
! typedef hash_table <pointer_hash <gimple_statement_d> > gimple_htab;
  
  /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
     each matching BUILT_IN_STACK_RESTORE.  Mark visited phis in VISITED.  */
Index: gcc/tree-ssa-coalesce.c
===================================================================
*** gcc/tree-ssa-coalesce.c.orig	2012-08-16 10:33:59.000000000 +0200
--- gcc/tree-ssa-coalesce.c	2012-08-16 11:08:50.857277018 +0200
*************** coalesce_partitions (var_map map, ssa_co
*** 1258,1279 ****
      }
  }
  
! /* Returns a hash code for N.  */
  
  inline hashval_t
! hash_ssa_name_by_var (const_tree n)
  {
!   return (hashval_t) htab_hash_pointer (SSA_NAME_VAR (n));
  }
  
- /* Returns nonzero if N1 and N2 are equal.  */
- 
  inline int
! eq_ssa_name_by_var (const_tree n1, const_tree n2)
  {
    return SSA_NAME_VAR (n1) == SSA_NAME_VAR (n2);
  }
  
  /* Reduce the number of copies by coalescing variables in the function.  Return
     a partition map with the resulting coalesces.  */
  
--- 1258,1286 ----
      }
  }
  
! 
! /* Hashtable support for storing SSA names hashed by their SSA_NAME_VAR.  */
! 
! struct ssa_name_var_hash : typed_noop_remove <union tree_node>
! {
!   typedef union tree_node T;
!   static inline hashval_t hash (const_tree);
!   static inline int equal (const_tree, const_tree);
! };
  
  inline hashval_t
! ssa_name_var_hash::hash (const_tree n)
  {
!   return DECL_UID (SSA_NAME_VAR (n));
  }
  
  inline int
! ssa_name_var_hash::equal (const_tree n1, const_tree n2)
  {
    return SSA_NAME_VAR (n1) == SSA_NAME_VAR (n2);
  }
  
+ 
  /* Reduce the number of copies by coalescing variables in the function.  Return
     a partition map with the resulting coalesces.  */
  
*************** coalesce_ssa_name (void)
*** 1286,1294 ****
    bitmap used_in_copies = BITMAP_ALLOC (NULL);
    var_map map;
    unsigned int i;
!   static hash_table <tree_node, hash_ssa_name_by_var, eq_ssa_name_by_var,
! 		     typed_null_remove<tree_node> >
! 		    ssa_name_hash;
  
    cl = create_coalesce_list ();
    map = create_outofssa_var_map (cl, used_in_copies);
--- 1293,1299 ----
    bitmap used_in_copies = BITMAP_ALLOC (NULL);
    var_map map;
    unsigned int i;
!   static hash_table <ssa_name_var_hash> ssa_name_hash;
  
    cl = create_coalesce_list ();
    map = create_outofssa_var_map (cl, used_in_copies);
Index: gcc/tree-ssa-pre.c
===================================================================
*** gcc/tree-ssa-pre.c.orig	2012-08-16 10:33:59.000000000 +0200
--- gcc/tree-ssa-pre.c	2012-08-16 11:09:12.132276244 +0200
*************** typedef union pre_expr_union_d
*** 165,175 ****
    vn_reference_t reference;
  } pre_expr_union;
  
! typedef struct pre_expr_d
  {
    enum pre_expr_kind kind;
    unsigned int id;
    pre_expr_union u;
  } *pre_expr;
  
  #define PRE_EXPR_NAME(e) (e)->u.name
--- 165,180 ----
    vn_reference_t reference;
  } pre_expr_union;
  
! typedef struct pre_expr_d : typed_noop_remove <pre_expr_d>
  {
    enum pre_expr_kind kind;
    unsigned int id;
    pre_expr_union u;
+ 
+   /* hash_table support.  */
+   typedef pre_expr_d T;
+   static inline hashval_t hash (const pre_expr_d *);
+   static inline int equal (const pre_expr_d *, const pre_expr_d *);
  } *pre_expr;
  
  #define PRE_EXPR_NAME(e) (e)->u.name
*************** typedef struct pre_expr_d
*** 180,186 ****
  /* Compare E1 and E1 for equality.  */
  
  inline int
! ssa_pre_expr_eq (const struct pre_expr_d *e1, const struct pre_expr_d *e2)
  {
    if (e1->kind != e2->kind)
      return false;
--- 185,191 ----
  /* Compare E1 and E1 for equality.  */
  
  inline int
! pre_expr_d::equal (const struct pre_expr_d *e1, const struct pre_expr_d *e2)
  {
    if (e1->kind != e2->kind)
      return false;
*************** ssa_pre_expr_eq (const struct pre_expr_d
*** 205,211 ****
  /* Hash E.  */
  
  inline hashval_t
! ssa_pre_expr_hash (const struct pre_expr_d *e)
  {
    switch (e->kind)
      {
--- 210,216 ----
  /* Hash E.  */
  
  inline hashval_t
! pre_expr_d::hash (const struct pre_expr_d *e)
  {
    switch (e->kind)
      {
*************** static unsigned int next_expression_id;
*** 229,237 ****
  DEF_VEC_P (pre_expr);
  DEF_VEC_ALLOC_P (pre_expr, heap);
  static VEC(pre_expr, heap) *expressions;
! static hash_table <pre_expr_d, ssa_pre_expr_hash, ssa_pre_expr_eq,
! 		   typed_null_remove <pre_expr_d> >
! 		  expression_to_id;
  static VEC(unsigned, heap) *name_to_id;
  
  /* Allocate an expression id for EXPR.  */
--- 234,240 ----
  DEF_VEC_P (pre_expr);
  DEF_VEC_ALLOC_P (pre_expr, heap);
  static VEC(pre_expr, heap) *expressions;
! static hash_table <pre_expr_d> expression_to_id;
  static VEC(unsigned, heap) *name_to_id;
  
  /* Allocate an expression id for EXPR.  */
*************** static bitmap need_ab_cleanup;
*** 483,489 ****
  /* A three tuple {e, pred, v} used to cache phi translations in the
     phi_translate_table.  */
  
! typedef struct expr_pred_trans_d
  {
    /* The expression.  */
    pre_expr e;
--- 486,492 ----
  /* A three tuple {e, pred, v} used to cache phi translations in the
     phi_translate_table.  */
  
! typedef struct expr_pred_trans_d : typed_free_remove<expr_pred_trans_d>
  {
    /* The expression.  */
    pre_expr e;
*************** typedef struct expr_pred_trans_d
*** 497,519 ****
    /* The hashcode for the expression, pred pair. This is cached for
       speed reasons.  */
    hashval_t hashcode;
  } *expr_pred_trans_t;
  typedef const struct expr_pred_trans_d *const_expr_pred_trans_t;
  
- /* Return the hash value for a phi translation table entry.  */
- 
  inline hashval_t
! ssa_expr_pred_trans_hash (const expr_pred_trans_d *ve)
  {
!   return ve->hashcode;
  }
  
- /* Return true if two phi translation table entries are the same.
-    P1 and P2 should point to the expr_pred_trans_t's to be compared.*/
- 
  inline int
! ssa_expr_pred_trans_eq (const expr_pred_trans_d *ve1,
! 			const expr_pred_trans_d *ve2)
  {
    basic_block b1 = ve1->pred;
    basic_block b2 = ve2->pred;
--- 500,522 ----
    /* The hashcode for the expression, pred pair. This is cached for
       speed reasons.  */
    hashval_t hashcode;
+ 
+   /* hash_table support.  */
+   typedef expr_pred_trans_d T;
+   static inline hashval_t hash (const expr_pred_trans_d *);
+   static inline int equal (const expr_pred_trans_d *, const expr_pred_trans_d *);
  } *expr_pred_trans_t;
  typedef const struct expr_pred_trans_d *const_expr_pred_trans_t;
  
  inline hashval_t
! expr_pred_trans_d::hash (const expr_pred_trans_d *e)
  {
!   return e->hashcode;
  }
  
  inline int
! expr_pred_trans_d::equal (const expr_pred_trans_d *ve1,
! 			  const expr_pred_trans_d *ve2)
  {
    basic_block b1 = ve1->pred;
    basic_block b2 = ve2->pred;
*************** ssa_expr_pred_trans_eq (const expr_pred_
*** 522,537 ****
       be equal.  */
    if (b1 != b2)
      return false;
!   return ssa_pre_expr_eq (ve1->e, ve2->e);
  }
  
  /* The phi_translate_table caches phi translations for a given
     expression and predecessor.  */
! 
! static hash_table <expr_pred_trans_d, ssa_expr_pred_trans_hash,
! 		   ssa_expr_pred_trans_eq,
! 		   typed_free_remove <expr_pred_trans_d> >
! 		  phi_translate_table;
  
  /* Search in the phi translation table for the translation of
     expression E in basic block PRED.
--- 525,536 ----
       be equal.  */
    if (b1 != b2)
      return false;
!   return pre_expr_d::equal (ve1->e, ve2->e);
  }
  
  /* The phi_translate_table caches phi translations for a given
     expression and predecessor.  */
! static hash_table <expr_pred_trans_d> phi_translate_table;
  
  /* Search in the phi translation table for the translation of
     expression E in basic block PRED.
*************** phi_trans_lookup (pre_expr e, basic_bloc
*** 545,551 ****
  
    ept.e = e;
    ept.pred = pred;
!   ept.hashcode = iterative_hash_hashval_t (ssa_pre_expr_hash (e), pred->index);
    slot = phi_translate_table.find_slot_with_hash (&ept, ept.hashcode,
  				   NO_INSERT);
    if (!slot)
--- 544,550 ----
  
    ept.e = e;
    ept.pred = pred;
!   ept.hashcode = iterative_hash_hashval_t (pre_expr_d::hash (e), pred->index);
    slot = phi_translate_table.find_slot_with_hash (&ept, ept.hashcode,
  				   NO_INSERT);
    if (!slot)
*************** phi_trans_add (pre_expr e, pre_expr v, b
*** 566,572 ****
    new_pair->e = e;
    new_pair->pred = pred;
    new_pair->v = v;
!   new_pair->hashcode = iterative_hash_hashval_t (ssa_pre_expr_hash (e),
  						 pred->index);
  
    slot = phi_translate_table.find_slot_with_hash (new_pair,
--- 565,571 ----
    new_pair->e = e;
    new_pair->pred = pred;
    new_pair->v = v;
!   new_pair->hashcode = iterative_hash_hashval_t (pre_expr_d::hash (e),
  						 pred->index);
  
    slot = phi_translate_table.find_slot_with_hash (new_pair,
*************** do_regular_insertion (basic_block block,
*** 3495,3501 ****
  		    do_insertion = true;
  		  if (first_s == NULL)
  		    first_s = edoubleprime;
! 		  else if (!ssa_pre_expr_eq (first_s, edoubleprime))
  		    all_same = false;
  		}
  	    }
--- 3494,3500 ----
  		    do_insertion = true;
  		  if (first_s == NULL)
  		    first_s = edoubleprime;
! 		  else if (!pre_expr_d::equal (first_s, edoubleprime))
  		    all_same = false;
  		}
  	    }
Index: gcc/tree-ssa-tail-merge.c
===================================================================
*** gcc/tree-ssa-tail-merge.c.orig	2012-08-16 10:33:59.000000000 +0200
--- gcc/tree-ssa-tail-merge.c	2012-08-16 10:50:44.530314595 +0200
*************** struct same_succ_def
*** 224,233 ****
--- 224,247 ----
    bool in_worklist;
    /* The hash value of the struct.  */
    hashval_t hashval;
+ 
+   /* hash_table support.  */
+   typedef same_succ_def T;
+   static inline hashval_t hash (const same_succ_def *);
+   static int equal (const same_succ_def *, const same_succ_def *);
+   static void remove (same_succ_def *);
  };
  typedef struct same_succ_def *same_succ;
  typedef const struct same_succ_def *const_same_succ;
  
+ /* hash routine for hash_table support, returns hashval of E.  */
+ 
+ inline hashval_t
+ same_succ_def::hash (const same_succ_def *e)
+ {
+   return e->hashval;
+ }
+ 
  /* A group of bbs where 1 bb from bbs can replace the other bbs.  */
  
  struct bb_cluster_def
*************** stmt_update_dep_bb (gimple stmt)
*** 415,422 ****
  
  /* Calculates hash value for same_succ VE.  */
  
! hashval_t
! ssa_same_succ_hash (const_same_succ e)
  {
    hashval_t hashval = bitmap_hash (e->succs);
    int flags;
--- 429,436 ----
  
  /* Calculates hash value for same_succ VE.  */
  
! static hashval_t
! same_succ_hash (const_same_succ e)
  {
    hashval_t hashval = bitmap_hash (e->succs);
    int flags;
*************** inverse_flags (const_same_succ e1, const
*** 511,520 ****
    return (f1a & mask) == (f2a & mask) && (f1b & mask) == (f2b & mask);
  }
  
! /* Compares SAME_SUCCs VE1 and VE2.  */
  
  int
! ssa_same_succ_equal (const_same_succ e1, const_same_succ e2)
  {
    unsigned int i, first1, first2;
    gimple_stmt_iterator gsi1, gsi2;
--- 525,534 ----
    return (f1a & mask) == (f2a & mask) && (f1b & mask) == (f2b & mask);
  }
  
! /* Compares SAME_SUCCs E1 and E2.  */
  
  int
! same_succ_def::equal (const_same_succ e1, const_same_succ e2)
  {
    unsigned int i, first1, first2;
    gimple_stmt_iterator gsi1, gsi2;
*************** same_succ_alloc (void)
*** 584,593 ****
    return same;
  }
  
! /* Delete same_succ VE.  */
  
! inline void
! ssa_same_succ_delete (same_succ e)
  {
    BITMAP_FREE (e->bbs);
    BITMAP_FREE (e->succs);
--- 598,607 ----
    return same;
  }
  
! /* Delete same_succ E.  */
  
! void
! same_succ_def::remove (same_succ e)
  {
    BITMAP_FREE (e->bbs);
    BITMAP_FREE (e->succs);
*************** same_succ_reset (same_succ same)
*** 608,618 ****
    VEC_truncate (int, same->succ_flags, 0);
  }
  
! /* Hash table with all same_succ entries.  */
! 
! static hash_table <struct same_succ_def, ssa_same_succ_hash,
! 		   ssa_same_succ_equal, ssa_same_succ_delete>
! 		  same_succ_htab;
  
  /* Array that is used to store the edge flags for a successor.  */
  
--- 622,628 ----
    VEC_truncate (int, same->succ_flags, 0);
  }
  
! static hash_table <same_succ_def> same_succ_htab;
  
  /* Array that is used to store the edge flags for a successor.  */
  
*************** find_same_succ_bb (basic_block bb, same_
*** 692,698 ****
    EXECUTE_IF_SET_IN_BITMAP (same->succs, 0, j, bj)
      VEC_safe_push (int, heap, same->succ_flags, same_succ_edge_flags[j]);
  
!   same->hashval = ssa_same_succ_hash (same);
  
    slot = same_succ_htab.find_slot_with_hash (same, same->hashval, INSERT);
    if (*slot == NULL)
--- 702,708 ----
    EXECUTE_IF_SET_IN_BITMAP (same->succs, 0, j, bj)
      VEC_safe_push (int, heap, same->succ_flags, same_succ_edge_flags[j]);
  
!   same->hashval = same_succ_hash (same);
  
    slot = same_succ_htab.find_slot_with_hash (same, same->hashval, INSERT);
    if (*slot == NULL)
*************** find_same_succ (void)
*** 728,734 ****
  	same = same_succ_alloc ();
      }
  
!   ssa_same_succ_delete (same);
  }
  
  /* Initializes worklist administration.  */
--- 738,744 ----
  	same = same_succ_alloc ();
      }
  
!   same_succ_def::remove (same);
  }
  
  /* Initializes worklist administration.  */
*************** update_worklist (void)
*** 860,866 ****
        if (same == NULL)
  	same = same_succ_alloc ();
      }
!   ssa_same_succ_delete (same);
    bitmap_clear (deleted_bb_preds);
  }
  
--- 870,876 ----
        if (same == NULL)
  	same = same_succ_alloc ();
      }
!   same_succ_def::remove (same);
    bitmap_clear (deleted_bb_preds);
  }
  
Index: gcc/tree-ssa-threadupdate.c
===================================================================
*** gcc/tree-ssa-threadupdate.c.orig	2012-08-16 10:33:59.000000000 +0200
--- gcc/tree-ssa-threadupdate.c	2012-08-16 11:04:35.307285820 +0200
*************** struct el
*** 110,116 ****
     may have many incoming edges threaded to the same outgoing edge.  This
     can be naturally implemented with a hash table.  */
  
! struct redirection_data
  {
    /* A duplicate of B with the trailing control statement removed and which
       targets a single successor of B.  */
--- 110,116 ----
     may have many incoming edges threaded to the same outgoing edge.  This
     can be naturally implemented with a hash table.  */
  
! struct redirection_data : typed_free_remove<redirection_data>
  {
    /* A duplicate of B with the trailing control statement removed and which
       targets a single successor of B.  */
*************** struct redirection_data
*** 125,132 ****
--- 125,154 ----
    /* A list of incoming edges which we want to thread to
       OUTGOING_EDGE->dest.  */
    struct el *incoming_edges;
+ 
+   /* hash_table support.  */
+   typedef redirection_data T;
+   static inline hashval_t hash (const redirection_data *);
+   static inline int equal (const redirection_data *, const redirection_data *);
  };
  
+ inline hashval_t
+ redirection_data::hash (const redirection_data *p)
+ {
+   edge e = p->outgoing_edge;
+   return e->dest->index;
+ }
+ 
+ inline int
+ redirection_data::equal (const redirection_data *p1, const redirection_data *p2)
+ {
+   edge e1 = p1->outgoing_edge;
+   edge e2 = p2->outgoing_edge;
+   edge e3 = p1->intermediate_edge;
+   edge e4 = p2->intermediate_edge;
+   return e1 == e2 && e3 == e4;
+ }
+ 
  /* Data structure of information to pass to hash table traversal routines.  */
  struct ssa_local_info_t
  {
*************** create_block_for_threading (basic_block
*** 217,248 ****
    rd->dup_block->count = 0;
  }
  
- /* Hashing and equality routines for our hash table.  */
- inline hashval_t
- ssa_redirection_data_hash (const struct redirection_data *p)
- {
-   edge e = p->outgoing_edge;
-   return e->dest->index;
- }
- 
- inline int
- ssa_redirection_data_eq (const struct redirection_data *p1,
- 			 const struct redirection_data *p2)
- {
-   edge e1 = p1->outgoing_edge;
-   edge e2 = p2->outgoing_edge;
-   edge e3 = p1->intermediate_edge;
-   edge e4 = p2->intermediate_edge;
- 
-   return e1 == e2 && e3 == e4;
- }
- 
  /* Main data structure to hold information for duplicates of BB.  */
  
! static hash_table <struct redirection_data, ssa_redirection_data_hash,
! 		   ssa_redirection_data_eq,
! 		   typed_free_remove<struct redirection_data> >
! 		  redirection_data;
  
  /* Given an outgoing edge E lookup and return its entry in our hash table.
  
--- 239,247 ----
    rd->dup_block->count = 0;
  }
  
  /* Main data structure to hold information for duplicates of BB.  */
  
! static hash_table <redirection_data> redirection_data;
  
  /* Given an outgoing edge E lookup and return its entry in our hash table.
Richard Guenther - Aug. 16, 2012, 2:55 p.m.
On Thu, 16 Aug 2012, Paolo Carlini wrote:

> Hi,
> 
> I have another "out of curiosity"-type question ;)
> 
> On 08/16/2012 11:19 AM, Richard Guenther wrote:
> > 
> > !
> > ! template <typename Element>
> > ! inline int
> > ! pointer_hash<Element>::equal (const T *existing,
> > ! 			      const T *candidate)
> > ! {
> > !   return existing == candidate;
> >    }
> are these uses in the new code of int instead of bool intended or
> "historical"? Seem weird, definitely from the C++ (but even from the C) point
> of view.

Historical, copying what libiberty htab did.

Richard.
Paolo Carlini - Aug. 16, 2012, 2:56 p.m.
Hi,

I have another "out of curiosity"-type question ;)

On 08/16/2012 11:19 AM, Richard Guenther wrote:
>
> !
> ! template <typename Element>
> ! inline int
> ! pointer_hash<Element>::equal (const T *existing,
> ! 			      const T *candidate)
> ! {
> !   return existing == candidate;
>    }
are these uses in the new code of int instead of bool intended or 
"historical"? Seem weird, definitely from the C++ (but even from the C) 
point of view.

Paolo.
Lawrence Crowl - Aug. 16, 2012, 7:02 p.m.
On 8/16/12, Richard Guenther <rguenther@suse.de> wrote:
> On Wed, 15 Aug 2012, Lawrence Crowl wrote:
> > On 8/15/12, Richard Henderson <rth@redhat.com> wrote:
> > > On 2012-08-15 07:29, Richard Guenther wrote:
> > > > +   typedef typename Element::Element_t Element_t;
> > >
> > > Can we use something less ugly than Element_t?
> > > Such as
> > >
> > >   typedef typename Element::T T;
> > >
> > > ?  Given that this name is scoped anyway...
> >
> > I do not much like _t names either.
>
> The following is what I'm testing now, it also integrates the
> hashtable support functions and typedef within the existing local
> data types which is IMHO cleaner.  (it also shows we can do with
> a janitorial cleanup replacing typedef struct foo_d {} foo; with
> struct foo {}; and the likes)

Yes.

> Bootstrap and regtest ongoing on x86_64-unknown-linux-gnu, ok?

Looks good to me.

I would have prefered the Element->T rename in a separate patch
so that it is easier to see the core difference.
Lawrence Crowl - Sept. 25, 2012, 9:30 p.m.
On 8/15/12, Richard Henderson <rth@redhat.com> wrote:
> On 2012-08-15 07:29, Richard Guenther wrote:
> > +   typedef typename Element::Element_t Element_t;
>
> Can we use something less ugly than Element_t?
> Such as
>
>   typedef typename Element::T T;
>
> ?  Given that this name is scoped anyway...

I've been finding the use of T as a typedef confusing.  It sort of
flies in the face of all existing convention.  The C++ standard would
use either element_type or value_type.  I suggest a rename, but I'm
guessing that folks don't want something as verbose as element_type.
How about elemtype?  Any objections to me changing it to that?
Michael Matz - Sept. 26, 2012, 12:22 p.m.
Hi,

On Tue, 25 Sep 2012, Lawrence Crowl wrote:

> On 8/15/12, Richard Henderson <rth@redhat.com> wrote:
> > On 2012-08-15 07:29, Richard Guenther wrote:
> > > +   typedef typename Element::Element_t Element_t;
> >
> > Can we use something less ugly than Element_t?
> > Such as
> >
> >   typedef typename Element::T T;
> >
> > ?  Given that this name is scoped anyway...
> 
> I've been finding the use of T as a typedef confusing.

Why?  As type placeholder in templates it's quite customary, as the "most 
interesting to users of this template".  I would have no trouble at all to 
see declarations like "T x = getme();" in a function.  In some way I even 
prefer that to some lower-case variant, because it reminds me that this 
specific "T" is actually variant.

A lower-case type name indicates to me a non-changing type, i.e. nothing 
that depends on a template.  In C we only had such types so we used 
lower-case names everywhere.  With C++ and templates I think we should 
start using upper case for some very specific use cases, like first letter 
of dependend types.

> It sort of flies in the face of all existing convention.

If you talk about the conventions used for the c++ standard library, then 
they are IMHO quite ugly and we should not follow them.


Ciao,
Michael.
Gabriel Dos Reis - Sept. 26, 2012, 2:34 p.m.
On Tue, Sep 25, 2012 at 4:30 PM, Lawrence Crowl <crowl@google.com> wrote:
> On 8/15/12, Richard Henderson <rth@redhat.com> wrote:
>> On 2012-08-15 07:29, Richard Guenther wrote:
>> > +   typedef typename Element::Element_t Element_t;
>>
>> Can we use something less ugly than Element_t?
>> Such as
>>
>>   typedef typename Element::T T;
>>
>> ?  Given that this name is scoped anyway...
>
> I've been finding the use of T as a typedef confusing.  It sort of
> flies in the face of all existing convention.  The C++ standard would
> use either element_type or value_type.  I suggest a rename, but I'm
> guessing that folks don't want something as verbose as element_type.
> How about elemtype?  Any objections to me changing it to that?
>


In general, we would be better off following standard convention.
It does not seem to me that we have enough reasons and benefits in
building our own universe around this issue.  Consequently, I would suggest
that we use value_type or element_type in the interface -- which is better
served being readable: this is the *interface*.

I am pretty sure that people will quickly resort to local typedefs that are
more readable even if we adopt a short (therefore cryptic) abbreviations
such as T in the interface.  It is one more hurdle that has no reason to be.

-- Gaby
Lawrence Crowl - Sept. 26, 2012, 6:09 p.m.
On 9/26/12, Michael Matz <matz@suse.de> wrote:
> On Tue, 25 Sep 2012, Lawrence Crowl wrote:
> > On 8/15/12, Richard Henderson <rth@redhat.com> wrote:
> > > On 2012-08-15 07:29, Richard Guenther wrote:
> > > > typedef typename Element::Element_t Element_t;
> > >
> > > Can we use something less ugly than Element_t?
> > > Such as typedef typename Element::T T;
> > > ?  Given that this name is scoped anyway...
> >
> > I've been finding the use of T as a typedef confusing.
>
> Why?  As type placeholder in templates it's quite customary,
> as the "most interesting to users of this template".  I would
> have no trouble at all to see declarations like "T x = getme();"
> in a function.  In some way I even prefer that to some lower-case
> variant, because it reminds me that this specific "T" is actually
> variant.

The problem is that while T is customary as a template parameter, I
have never seen it used as a typedef name.  And that's the situation
that we are in now.

> A lower-case type name indicates to me a non-changing type,
> i.e. nothing that depends on a template.  In C we only had
> such types so we used lower-case names everywhere.  With C++
> and templates I think we should start using upper case for some
> very specific use cases, like first letter of dependend types.

How would you distinguish them from template parameter names,
which by convention have an upper case first letter?

What about non-type dependent names?

I think we really do need a separate convention for the two,
because dependent members of class templates often need special
access syntax.

> > It sort of flies in the face of all existing convention.
>
> If you talk about the conventions used for the c++ standard
> library, then they are IMHO quite ugly and we should not follow
> them.

The advantage to following them is that they will surprise no one.
Do you have an alternate suggestion, one that does not confuse
template parameters and dependent names?
Gabriel Dos Reis - Sept. 26, 2012, 6:17 p.m.
On Wed, Sep 26, 2012 at 1:09 PM, Lawrence Crowl <crowl@google.com> wrote:
>
> The problem is that while T is customary as a template parameter, I
> have never seen it used as a typedef name.  And that's the situation
> that we are in now.

this should be a no-brainer: T should be reserved for the name of the
template parameter.
[...]

> I think we really do need a separate convention for the two,
> because dependent members of class templates often need special
> access syntax.

Yes.

-- Gaby
Michael Matz - Sept. 27, 2012, 12:12 p.m.
Hi,

On Wed, 26 Sep 2012, Lawrence Crowl wrote:

> > A lower-case type name indicates to me a non-changing type,
> > i.e. nothing that depends on a template.  In C we only had
> > such types so we used lower-case names everywhere.  With C++
> > and templates I think we should start using upper case for some
> > very specific use cases, like first letter of dependend types.
> 
> How would you distinguish them from template parameter names,
> which by convention have an upper case first letter?

I wouldn't.  If the distinction becomes so important that authors need to 
see the speciality immediately by having a different convention how to 
spell names, then I think we did something wrong, and we should simplify 
the code.

> What about non-type dependent names?

I'm not sure what you're asking.  Let's make an example:

template <typename T>
struct D : B<T>
{
  typedef typename B<T>::E E; // element_type
  E getme (int index);
}

In fact, as B<T>::E would probably be defined like "typedef typename T E", 
I would even have no issue to call the above E also T.  The distinction 
between the template arg name and the typedef would be blurred, and I say, 
so what; one is a typedef of the other and hence mostly equivalent for 
practical purposes.  (And if they aren't, then again, we did something too 
complicated with the switch to C++).

> The advantage to following them is that they will surprise no one.

They will surprise everyone used to different conventions, for instance 
Qt, so that's not a reason.

> Do you have an alternate suggestion, one that does not confuse template 
> parameters and dependent names?

Upper last character?  Just kidding :)  Too many detailed rules for 
conventions are the death of them, use rules of thumbs, my one would be 
"somehow depends on template args -> has upper character in name", where 
"somehow depends on" includes "is a".


Ciao,
Michael.
Gabriel Dos Reis - Sept. 27, 2012, 12:19 p.m.
On Thu, Sep 27, 2012 at 7:12 AM, Michael Matz <matz@suse.de> wrote:

> (And if they aren't, then again, we did something too
> complicated with the switch to C++).

or we are doing something by insisting not to use
standard notation.
Lawrence Crowl - Sept. 27, 2012, 6:35 p.m.
On 9/27/12, Michael Matz <matz@suse.de> wrote:
> On Wed, 26 Sep 2012, Lawrence Crowl wrote:
> > > A lower-case type name indicates to me a non-changing type,
> > > i.e. nothing that depends on a template.  In C we only had
> > > such types so we used lower-case names everywhere.  With C++
> > > and templates I think we should start using upper case for some
> > > very specific use cases, like first letter of dependend types.
> >
> > How would you distinguish them from template parameter names,
> > which by convention have an upper case first letter?
>
> I wouldn't.  If the distinction becomes so important that authors
> need to see the speciality immediately by having a different
> convention how to spell names, then I think we did something wrong,
> and we should simplify the code.
>
> > What about non-type dependent names?
>
> I'm not sure what you're asking.  Let's make an example:
>
> template <typename T>
> struct D : B<T>
> {
>   typedef typename B<T>::E E; // element_type
>   E getme (int index);
> }

Inside that struct, lets say we have a field of type E.  Do we name
it F or f?

> In fact, as B<T>::E would probably be defined like "typedef
> typename T E", I would even have no issue to call the above E
> also T.  The distinction between the template arg name and the
> typedef would be blurred, and I say, so what; one is a typedef
> of the other and hence mostly equivalent for practical purposes.
> (And if they aren't, then again, we did something too complicated
> with the switch to C++).
>
> > The advantage to following them is that they will surprise
> > no one.
>
> They will surprise everyone used to different conventions, for
> instance Qt, so that's not a reason.

Anyone using the standard library will not be surprised if we follow
the conventions of the standard library.  I'd guess that the number
standard library programmers outnumbers the Qt programmers by 100
to 1.  I'd guess that the number of Qt programmers that do not know
the standard library is a minority.

> > Do you have an alternate suggestion, one that does not confuse
> > template parameters and dependent names?
>
> Upper last character?  Just kidding :)  Too many detailed rules
> for conventions are the death of them, use rules of thumbs,
> my one would be "somehow depends on template args -> has upper
> character in name", where "somehow depends on" includes "is a".

Ah, but there is a problem.  That typedef name does not necessarily
depend on a template parameter.

It is common practice to have

struct Q
{
  typedef int E;
  E getme (int index);
};

and use it in exactly the same places you would use D<something>.

In fact, one place is in the hash table code we are discussing.
The hash descriptor type may not itself be a template.  I believe
that few of them will actually be templates.

So, if E implies comes from template, the implication is wrong.

If we were to follow C++ standard library conventions, we would call
it value_type.  That would be my preference.  However, if folks
want a shorter name, I'll live with that too.  But as it stands,
the current name is very confusing.
Gabriel Dos Reis - Sept. 27, 2012, 11:31 p.m.
On Thu, Sep 27, 2012 at 1:35 PM, Lawrence Crowl <crowl@google.com> wrote:

> If we were to follow C++ standard library conventions, we would call
> it value_type.  That would be my preference.  However, if folks
> want a shorter name, I'll live with that too.  But as it stands,
> the current name is very confusing.

Yes, and there appears to be no good reason to let it stand.

-- Gaby
Michael Matz - Sept. 28, 2012, 1:18 p.m.
Hi,

On Thu, 27 Sep 2012, Lawrence Crowl wrote:

> > template <typename T>
> > struct D : B<T>
> > {
> >   typedef typename B<T>::E E; // element_type
> >   E getme (int index);
> > }
> 
> Inside that struct, lets say we have a field of type E.  Do we name
> it F or f?

IMHO only for types, not for any other decls.

> > > Do you have an alternate suggestion, one that does not confuse
> > > template parameters and dependent names?
> >
> > Upper last character?  Just kidding :)  Too many detailed rules
> > for conventions are the death of them, use rules of thumbs,
> > my one would be "somehow depends on template args -> has upper
> > character in name", where "somehow depends on" includes "is a".
> 
> Ah, but there is a problem.  That typedef name does not necessarily
> depend on a template parameter.
> 
> It is common practice to have
> 
> struct Q
> {
>   typedef int E;
>   E getme (int index);
> };

Easy: I wouldn't make a typedef for Q::E that merely is int.  The reason 
is that it makes knowing what getme really returns harder.  You have to 
look it up always (or know the class already).  In fact that's one of my 
gripes with the standard library, much too much indirection through 
entities merely referring to other entities.  Might be only important for 
the libraries implementors but I sure hope that we don't start down that 
road in GCC.

> In fact, one place is in the hash table code we are discussing.
> The hash descriptor type may not itself be a template.  I believe
> that few of them will actually be templates.

Then I don't see the need for class-local typedefs.

> So, if E implies comes from template, the implication is wrong.
> 
> If we were to follow C++ standard library conventions, we would call it 
> value_type.

Well, but value_type surely does depend on the hashtables type argument, 
doesn't it?   After all it is a typedef from 'Key'.
I would expect that htab<tree>::value_type is tree, and 
htab<int>::value_type is int, and I would like to see it named 
htab<tree>::T or ::E.

> That would be my preference.  However, if folks want a shorter name, 
> I'll live with that too.  But as it stands, the current name is very 
> confusing.

I would even prefer 'e' over value_type.  It's scoped, the context always 
will be clear, no need to be verbose in that name.  I find the long names 
inelegant, as most of the standard libs conventions.


Ciao,
Michael.
Gabriel Dos Reis - Sept. 28, 2012, 2:25 p.m.
On Fri, Sep 28, 2012 at 8:18 AM, Michael Matz <matz@suse.de> wrote:

>> It is common practice to have
>>
>> struct Q
>> {
>>   typedef int E;
>>   E getme (int index);
>> };
>
> Easy: I wouldn't make a typedef for Q::E that merely is int.  The reason
> is that it makes knowing what getme really returns harder.

The point of these nested type is precisely to allow  a *uniform* access
to associated from within a template (e.g. a container) -- irrespective of
what those types happen to resolve to, builtin or not.

-- Gaby
Lawrence Crowl - Sept. 28, 2012, 7:40 p.m.
On 9/28/12, Michael Matz <matz@suse.de> wrote:
> On Thu, 27 Sep 2012, Lawrence Crowl wrote:
> > > template <typename T>
> > > struct D : B<T>
> > > {
> > >   typedef typename B<T>::E E; // element_type
> > >   E getme (int index);
> > > }
> >
> > Inside that struct, lets say we have a field of type E.  Do we name
> > it F or f?
>
> IMHO only for types, not for any other decls.
>
> > > > Do you have an alternate suggestion, one that does not confuse
> > > > template parameters and dependent names?
> > >
> > > Upper last character?  Just kidding :)  Too many detailed rules
> > > for conventions are the death of them, use rules of thumbs,
> > > my one would be "somehow depends on template args -> has upper
> > > character in name", where "somehow depends on" includes "is a".
> >
> > Ah, but there is a problem.  That typedef name does not necessarily
> > depend on a template parameter.
> >
> > It is common practice to have
> >
> > struct Q
> > {
> >   typedef int E;
> >   E getme (int index);
> > };
>
> Easy: I wouldn't make a typedef for Q::E that merely is int.  The reason
> is that it makes knowing what getme really returns harder.  You have to
> look it up always (or know the class already).  In fact that's one of my
> gripes with the standard library, much too much indirection through
> entities merely referring to other entities.  Might be only important for
> the libraries implementors but I sure hope that we don't start down that
> road in GCC.
>
> > In fact, one place is in the hash table code we are discussing.
> > The hash descriptor type may not itself be a template.  I believe
> > that few of them will actually be templates.
>
> Then I don't see the need for class-local typedefs.
>
> > So, if E implies comes from template, the implication is wrong.
> >
> > If we were to follow C++ standard library conventions, we would call it
> > value_type.
>
> Well, but value_type surely does depend on the hashtables
> type argument, doesn't it?  After all it is a typedef from
> 'Key'.  I would expect that htab<tree>::value_type is tree, and
> htab<int>::value_type is int, and I would like to see it named
> htab<tree>::T or ::E.

One declares a hash table as follows.

  hash_table <hash_descriptor> variable;

The type stored in the hash table is not part of the declaration.
It is part of the descriptor, along with other things like the
hash function.  The hash table essentially queries the descriptor
for the value type.  For example,

  template <Descriptor> class hash_table {
    typename Descriptor::value_type *storage;
    ...

More typically though, the typedef is repeated inside the class to
avoid excess verbosity, and more importantly, to reexport the name.

  template <Descriptor> class hash_table {
    typedef typename Descriptor::value_type value_type;
    value_type *storage;
    ...

Using these typedef names is an essential component of the
abstraction.  Without it, we end up going to void* and loosing all
type safety.

> > That would be my preference.  However, if folks want a shorter name,
> > I'll live with that too.  But as it stands, the current name is very
> > confusing.
>
> I would even prefer 'e' over value_type.  It's scoped, the context always
> will be clear, no need to be verbose in that name.  I find the long names
> inelegant, as most of the standard libs conventions.

We need some convention.  If we choose a convention different from
the standard library, then we are essentially saying that we do not
intend to interoperate with the standard library.  I do not think
that is the intent of the community, but I could be wrong about that.
Diego Novillo - Sept. 28, 2012, 7:43 p.m.
On Fri, Sep 28, 2012 at 12:40 PM, Lawrence Crowl <crowl@google.com> wrote:
> On 9/28/12, Michael Matz <matz@suse.de> wrote:
>>
>> I would even prefer 'e' over value_type.  It's scoped, the context always
>> will be clear, no need to be verbose in that name.  I find the long names
>> inelegant, as most of the standard libs conventions.
>
> We need some convention.  If we choose a convention different from
> the standard library, then we are essentially saying that we do not
> intend to interoperate with the standard library.  I do not think
> that is the intent of the community, but I could be wrong about that.

I agree.  If there already exists a convention that is widely known
and recognized, then we should use it.  There is negative value in
inventing a new convention.  We need to lower barriers to adoption,
not raise them.

Using the standard library convention seems to me like the best thing
to do here.


Diego.
Lawrence Crowl - Sept. 28, 2012, 7:45 p.m.
On 9/28/12, Gabriel Dos Reis <gdr@integrable-solutions.net> wrote:
> On Fri, Sep 28, 2012 at 8:18 AM, Michael Matz <matz@suse.de> wrote:
>>> It is common practice to have
>>>
>>> struct Q
>>> {
>>>   typedef int E;
>>>   E getme (int index);
>>> };
>>
>> Easy: I wouldn't make a typedef for Q::E that merely is int.  The reason
>> is that it makes knowing what getme really returns harder.
>
> The point of these nested type is precisely to allow  a *uniform* access
> to associated from within a template (e.g. a container) -- irrespective of
> what those types happen to resolve to, builtin or not.

Perhaps an analogy might be helpful.  If I say "Tim's father" you know
role of that person without knowing exactly who it is.  The typedef
convention serves the same purpose.  It is important that we use the
same term for father, or we wouldn't be able to communicate.

Patch

Index: gcc/hash-table.h
===================================================================
--- gcc/hash-table.h	(revision 190410)
+++ gcc/hash-table.h	(working copy)
@@ -199,45 +199,42 @@  struct hash_table_control
 */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator = xcallocator>
 class hash_table
 {
+public:
+  typedef typename Element::Element_t Element_t;
 
 private:
+  hash_table_control <Element_t> *htab;
 
-  hash_table_control <Element> *htab;
-
-  Element **find_empty_slot_for_expand (hashval_t hash);
+  Element_t **find_empty_slot_for_expand (hashval_t hash);
   void expand ();
 
 public:
-
   hash_table ();
   void create (size_t initial_slots);
   bool is_created ();
   void dispose ();
-  Element *find (Element *comparable);
-  Element *find_with_hash (Element *comparable, hashval_t hash);
-  Element **find_slot (Element *comparable, enum insert_option insert);
-  Element **find_slot_with_hash (Element *comparable, hashval_t hash,
-				 enum insert_option insert);
+  Element_t *find (Element_t *comparable);
+  Element_t *find_with_hash (Element_t *comparable, hashval_t hash);
+  Element_t **find_slot (Element_t *comparable, enum insert_option insert);
+  Element_t **find_slot_with_hash (Element_t *comparable, hashval_t hash,
+				   enum insert_option insert);
   void empty ();
-  void clear_slot (Element **slot);
-  void remove_elt (Element *comparable);
-  void remove_elt_with_hash (Element *comparable, hashval_t hash);
+  void clear_slot (Element_t **slot);
+  void remove_elt (Element_t *comparable);
+  void remove_elt_with_hash (Element_t *comparable, hashval_t hash);
   size_t size();
   size_t elements();
   double collisions();
 
   template <typename Argument,
-	    int (*Callback) (Element **slot, Argument argument)>
+	    int (*Callback) (Element_t **slot, Argument argument)>
   void traverse_noresize (Argument argument);
 
   template <typename Argument,
-	    int (*Callback) (Element **slot, Argument argument)>
+	    int (*Callback) (Element_t **slot, Argument argument)>
   void traverse (Argument argument);
 };
 
@@ -245,12 +242,9 @@  public:
 /* Construct the hash table.  The only useful operation next is create.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 inline
-hash_table <Element, Hash, Equal, Remove, Allocator>::hash_table ()
+hash_table <Element, Allocator>::hash_table ()
 : htab (NULL)
 {
 }
@@ -259,12 +253,9 @@  hash_table <Element, Hash, Equal, Remove
 /* See if the table has been created, as opposed to constructed.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 inline bool
-hash_table <Element, Hash, Equal, Remove, Allocator>::is_created ()
+hash_table <Element, Allocator>::is_created ()
 {
   return htab != NULL;
 }
@@ -273,56 +264,44 @@  hash_table <Element, Hash, Equal, Remove
 /* Like find_with_hash, but compute the hash value from the element.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
-inline Element *
-hash_table <Element, Hash, Equal, Remove, Allocator>::find (Element *comparable)
+inline typename Element::Element_t *
+hash_table <Element, Allocator>::find (Element_t *comparable)
 {
-  return find_with_hash (comparable, Hash (comparable));
+  return find_with_hash (comparable, Element::Hash (comparable));
 }
 
 
 /* Like find_slot_with_hash, but compute the hash value from the element.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
-	  template <typename Type> class Allocator>
-inline Element **
-hash_table <Element, Hash, Equal, Remove, Allocator>
-::find_slot (Element *comparable, enum insert_option insert)
+	  template <typename Type> class Allocator>
+inline typename Element::Element_t **
+hash_table <Element, Allocator>
+::find_slot (Element_t *comparable, enum insert_option insert)
 {
-  return find_slot_with_hash (comparable, Hash (comparable), insert);
+  return find_slot_with_hash (comparable, Element::Hash (comparable), insert);
 }
 
 
 /* Like remove_elt_with_hash, but compute the hash value from the element.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 inline void
-hash_table <Element, Hash, Equal, Remove, Allocator>
-::remove_elt (Element *comparable)
+hash_table <Element, Allocator>
+::remove_elt (Element_t *comparable)
 {
-  remove_elt_with_hash (comparable, Hash (comparable));
+  remove_elt_with_hash (comparable, Element::Hash (comparable));
 }
 
 
 /* Return the current size of this hash table.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 inline size_t
-hash_table <Element, Hash, Equal, Remove, Allocator>::size()
+hash_table <Element, Allocator>::size()
 {
   return htab->size;
 }
@@ -331,12 +310,9 @@  hash_table <Element, Hash, Equal, Remove
 /* Return the current number of elements in this hash table. */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 inline size_t
-hash_table <Element, Hash, Equal, Remove, Allocator>::elements()
+hash_table <Element, Allocator>::elements()
 {
   return htab->n_elements - htab->n_deleted;
 }
@@ -346,12 +322,9 @@  hash_table <Element, Hash, Equal, Remove
      hash table. */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 inline double
-hash_table <Element, Hash, Equal, Remove, Allocator>::collisions()
+hash_table <Element, Allocator>::collisions()
 {
   if (htab->searches == 0)
     return 0.0;
@@ -363,21 +336,18 @@  hash_table <Element, Hash, Equal, Remove
 /* Create a hash table with at least the given number of INITIAL_SLOTS.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>::create (size_t size)
+hash_table <Element, Allocator>::create (size_t size)
 {
   unsigned int size_prime_index;
 
   size_prime_index = hash_table_higher_prime_index (size);
   size = prime_tab[size_prime_index].prime;
 
-  htab = Allocator <hash_table_control <Element> > ::control_alloc (1);
+  htab = Allocator <hash_table_control <Element_t> > ::control_alloc (1);
   gcc_assert (htab != NULL);
-  htab->entries = Allocator <Element*> ::data_alloc (size);
+  htab->entries = Allocator <Element_t*> ::data_alloc (size);
   gcc_assert (htab->entries != NULL);
   htab->size = size;
   htab->size_prime_index = size_prime_index;
@@ -388,22 +358,19 @@  hash_table <Element, Hash, Equal, Remove
    the non-created state.  Naturally the hash table must already exist.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>::dispose ()
+hash_table <Element, Allocator>::dispose ()
 {
   size_t size = htab->size;
-  Element **entries = htab->entries;
+  Element_t **entries = htab->entries;
 
   for (int i = size - 1; i >= 0; i--)
     if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
-      Remove (entries[i]);
+      Element::Remove (entries[i]);
 
-  Allocator <Element *> ::data_free (entries);
-  Allocator <hash_table_control <Element> > ::control_free (htab);
+  Allocator <Element_t *> ::data_free (entries);
+  Allocator <hash_table_control <Element_t> > ::control_free (htab);
   htab = NULL;
 }
 
@@ -416,17 +383,14 @@  hash_table <Element, Hash, Equal, Remove
    HASH is the hash value for the element to be inserted.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
-Element **
-hash_table <Element, Hash, Equal, Remove, Allocator>
+typename Element::Element_t **
+hash_table <Element, Allocator>
 ::find_empty_slot_for_expand (hashval_t hash)
 {
   hashval_t index = hash_table_mod1 (hash, htab->size_prime_index);
   size_t size = htab->size;
-  Element **slot = htab->entries + index;
+  Element_t **slot = htab->entries + index;
   hashval_t hash2;
 
   if (*slot == HTAB_EMPTY_ENTRY)
@@ -458,17 +422,14 @@  hash_table <Element, Hash, Equal, Remove
    will abort.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>::expand ()
+hash_table <Element, Allocator>::expand ()
 {
-  Element **oentries;
-  Element **olimit;
-  Element **p;
-  Element **nentries;
+  Element_t **oentries;
+  Element_t **olimit;
+  Element_t **p;
+  Element_t **nentries;
   size_t nsize, osize, elts;
   unsigned int oindex, nindex;
 
@@ -491,7 +452,7 @@  hash_table <Element, Hash, Equal, Remove
       nsize = osize;
     }
 
-  nentries = Allocator <Element *> ::data_alloc (nsize);
+  nentries = Allocator <Element_t *> ::data_alloc (nsize);
   gcc_assert (nentries != NULL);
   htab->entries = nentries;
   htab->size = nsize;
@@ -502,11 +463,11 @@  hash_table <Element, Hash, Equal, Remove
   p = oentries;
   do
     {
-      Element *x = *p;
+      Element_t *x = *p;
 
       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
         {
-          Element **q = find_empty_slot_for_expand (Hash (x));
+          Element_t **q = find_empty_slot_for_expand (Element::Hash (x));
 
           *q = x;
         }
@@ -515,7 +476,7 @@  hash_table <Element, Hash, Equal, Remove
     }
   while (p < olimit);
 
-  Allocator <Element *> ::data_free (oentries);
+  Allocator <Element_t *> ::data_free (oentries);
 }
 
 
@@ -524,17 +485,14 @@  hash_table <Element, Hash, Equal, Remove
    be used to insert or delete an element. */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
-	  template <typename Type> class Allocator>
-Element *
-hash_table <Element, Hash, Equal, Remove, Allocator>
-::find_with_hash (Element *comparable, hashval_t hash)
+	  template <typename Type> class Allocator>
+typename Element::Element_t *
+hash_table <Element, Allocator>
+::find_with_hash (Element_t *comparable, hashval_t hash)
 {
   hashval_t index, hash2;
   size_t size;
-  Element *entry;
+  Element_t *entry;
 
   htab->searches++;
   size = htab->size;
@@ -542,7 +500,7 @@  hash_table <Element, Hash, Equal, Remove
 
   entry = htab->entries[index];
   if (entry == HTAB_EMPTY_ENTRY
-      || (entry != HTAB_DELETED_ENTRY && Equal (entry, comparable)))
+      || (entry != HTAB_DELETED_ENTRY && Element::Equal (entry, comparable)))
     return entry;
 
   hash2 = hash_table_mod2 (hash, htab->size_prime_index);
@@ -555,7 +513,7 @@  hash_table <Element, Hash, Equal, Remove
 
       entry = htab->entries[index];
       if (entry == HTAB_EMPTY_ENTRY
-          || (entry != HTAB_DELETED_ENTRY && Equal (entry, comparable)))
+          || (entry != HTAB_DELETED_ENTRY && Element::Equal (entry, comparable)))
         return entry;
     }
 }
@@ -570,19 +528,16 @@  hash_table <Element, Hash, Equal, Remove
    entry, NULL may be returned if memory allocation fails. */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
-	  template <typename Type> class Allocator>
-Element **
-hash_table <Element, Hash, Equal, Remove, Allocator>
-::find_slot_with_hash (Element *comparable, hashval_t hash,
+	  template <typename Type> class Allocator>
+typename Element::Element_t **
+hash_table <Element, Allocator>
+::find_slot_with_hash (Element_t *comparable, hashval_t hash,
 		       enum insert_option insert)
 {
-  Element **first_deleted_slot;
+  Element_t **first_deleted_slot;
   hashval_t index, hash2;
   size_t size;
-  Element *entry;
+  Element_t *entry;
 
   size = htab->size;
   if (insert == INSERT && size * 3 <= htab->n_elements * 4)
@@ -601,7 +556,7 @@  hash_table <Element, Hash, Equal, Remove
     goto empty_entry;
   else if (entry == HTAB_DELETED_ENTRY)
     first_deleted_slot = &htab->entries[index];
-  else if (Equal (entry, comparable))
+  else if (Element::Equal (entry, comparable))
     return &htab->entries[index];
       
   hash2 = hash_table_mod2 (hash, htab->size_prime_index);
@@ -620,7 +575,7 @@  hash_table <Element, Hash, Equal, Remove
 	  if (!first_deleted_slot)
 	    first_deleted_slot = &htab->entries[index];
 	}
-      else if (Equal (entry, comparable))
+      else if (Element::Equal (entry, comparable))
 	return &htab->entries[index];
     }
 
@@ -631,7 +586,7 @@  hash_table <Element, Hash, Equal, Remove
   if (first_deleted_slot)
     {
       htab->n_deleted--;
-      *first_deleted_slot = static_cast <Element *> (HTAB_EMPTY_ENTRY);
+      *first_deleted_slot = static_cast <Element_t *> (HTAB_EMPTY_ENTRY);
       return first_deleted_slot;
     }
 
@@ -643,20 +598,17 @@  hash_table <Element, Hash, Equal, Remove
 /* This function clears all entries in the given hash table.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>::empty ()
+hash_table <Element, Allocator>::empty ()
 {
   size_t size = htab_size (htab);
-  Element **entries = htab->entries;
+  Element_t **entries = htab->entries;
   int i;
 
   for (i = size - 1; i >= 0; i--)
     if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
-      Remove (entries[i]);
+      Element::Remove (entries[i]);
 
   /* Instead of clearing megabyte, downsize the table.  */
   if (size > 1024*1024 / sizeof (PTR))
@@ -664,13 +616,13 @@  hash_table <Element, Hash, Equal, Remove
       int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR));
       int nsize = prime_tab[nindex].prime;
 
-      Allocator <Element *> ::data_free (htab->entries);
-      htab->entries = Allocator <Element *> ::data_alloc (nsize);
+      Allocator <Element_t *> ::data_free (htab->entries);
+      htab->entries = Allocator <Element_t *> ::data_alloc (nsize);
       htab->size = nsize;
       htab->size_prime_index = nindex;
     }
   else
-    memset (entries, 0, size * sizeof (Element *));
+    memset (entries, 0, size * sizeof (Element_t *));
   htab->n_deleted = 0;
   htab->n_elements = 0;
 }
@@ -681,19 +633,16 @@  hash_table <Element, Hash, Equal, Remove
    again. */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>
-::clear_slot (Element **slot)
+hash_table <Element, Allocator>
+::clear_slot (Element_t **slot)
 {
   if (slot < htab->entries || slot >= htab->entries + htab->size
       || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
     abort ();
 
-  Remove (*slot);
+  Element::Remove (*slot);
 
   *slot = HTAB_DELETED_ENTRY;
   htab->n_deleted++;
@@ -705,23 +654,20 @@  hash_table <Element, Hash, Equal, Remove
    matching element in the hash table, this function does nothing. */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>
-::remove_elt_with_hash (Element *comparable, hashval_t hash)
+hash_table <Element, Allocator>
+::remove_elt_with_hash (Element_t *comparable, hashval_t hash)
 {
-  Element **slot;
+  Element_t **slot;
 
   slot = find_slot_with_hash (comparable, hash, NO_INSERT);
   if (*slot == HTAB_EMPTY_ENTRY)
     return;
 
-  Remove (*slot);
+  Element::Remove (*slot);
 
-  *slot = static_cast <Element *> (HTAB_DELETED_ENTRY);
+  *slot = static_cast <Element_t *> (HTAB_DELETED_ENTRY);
   htab->n_deleted++;
 }
 
@@ -731,25 +677,22 @@  hash_table <Element, Hash, Equal, Remove
    ARGUMENT is passed as CALLBACK's second argument. */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 template <typename Argument,
-	  int (*Callback) (Element **slot, Argument argument)>
+	  int (*Callback) (typename Element::Element_t **slot, Argument argument)>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>
+hash_table <Element, Allocator>
 ::traverse_noresize (Argument argument)
 {
-  Element **slot;
-  Element **limit;
+  Element_t **slot;
+  Element_t **limit;
 
   slot = htab->entries;
   limit = slot + htab->size;
 
   do
     {
-      Element *x = *slot;
+      Element_t *x = *slot;
 
       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
         if (! Callback (slot, argument))
@@ -763,14 +706,11 @@  hash_table <Element, Hash, Equal, Remove
    to improve effectivity of subsequent calls.  */
 
 template <typename Element,
-	  hashval_t (*Hash) (const Element *candidate),
-	  int (*Equal) (const Element *existing, const Element * candidate),
-	  void (*Remove) (Element *retired),
 	  template <typename Type> class Allocator>
 template <typename Argument,
-	  int (*Callback) (Element **slot, Argument argument)>
+	  int (*Callback) (typename Element::Element_t **slot, Argument argument)>
 void
-hash_table <Element, Hash, Equal, Remove, Allocator>
+hash_table <Element, Allocator>
 ::traverse (Argument argument)
 {
   size_t size = htab->size;
Index: gcc/coverage.c
===================================================================
--- gcc/coverage.c	(revision 190410)
+++ gcc/coverage.c	(working copy)
@@ -143,30 +143,29 @@  get_gcov_unsigned_t (void)
   return lang_hooks.types.type_for_mode (mode, true);
 }
 
-inline hashval_t
-coverage_counts_entry_hash (const counts_entry_t *entry)
-{
-  return entry->ident * GCOV_COUNTERS + entry->ctr;
-}
-
-inline int
-coverage_counts_entry_eq (const counts_entry_t *entry1,
-                          const counts_entry_t *entry2)
-{
-  return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
-}
-
-inline void
-coverage_counts_entry_del (counts_entry_t *entry)
-{
-  free (entry->counts);
-  free (entry);
-}
+class coverage_hash {
+public:
+    typedef counts_entry_t Element_t;
+    static inline int Equal (const counts_entry_t *entry1,
+			     const counts_entry_t *entry2)
+      {
+	return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
+      }
+    static inline hashval_t
+    Hash (const counts_entry_t *entry)
+      {
+	return entry->ident * GCOV_COUNTERS + entry->ctr;
+      }
+    static inline void
+    Remove (counts_entry_t *entry)
+      {
+	free (entry->counts);
+	free (entry);
+      }
+};
 
 /* Hash table of count data.  */
-static hash_table <counts_entry_t, coverage_counts_entry_hash,
-		   coverage_counts_entry_eq, coverage_counts_entry_del>
-		  counts_hash;
+static hash_table <coverage_hash> counts_hash;
 
 /* Read in the counts file, if available.  */