Index: gcc/tree-parloops.c
===================================================================
--- gcc/tree-parloops.c	(revision 194549)
+++ gcc/tree-parloops.c	(working copy)
@@ -178,36 +178,44 @@ struct reduction_info
 				   operation.  */
 };

-/* Equality and hash functions for hashtab code.  */
+/* Reduction info hashtable helpers.  */

-static int
-reduction_info_eq (const void *aa, const void *bb)
+struct reduction_hasher : typed_free_remove <reduction_info>
 {
-  const struct reduction_info *a = (const struct reduction_info *) aa;
-  const struct reduction_info *b = (const struct reduction_info *) bb;
+  typedef reduction_info value_type;
+  typedef reduction_info compare_type;
+  static inline hashval_t hash (const value_type *);
+  static inline bool equal (const value_type *, const compare_type *);
+};
+
+/* Equality and hash functions for hashtab code.  */

+inline bool
+reduction_hasher::equal (const value_type *a, const compare_type *b)
+{
   return (a->reduc_phi == b->reduc_phi);
 }

-static hashval_t
-reduction_info_hash (const void *aa)
+inline hashval_t
+reduction_hasher::hash (const value_type *a)
 {
-  const struct reduction_info *a = (const struct reduction_info *) aa;
-
   return a->reduc_version;
 }

+typedef hash_table <reduction_hasher> reduction_info_table_type;
+
+
 static struct reduction_info *
-reduction_phi (htab_t reduction_list, gimple phi)
+reduction_phi (reduction_info_table_type reduction_list, gimple phi)
 {
   struct reduction_info tmpred, *red;

-  if (htab_elements (reduction_list) == 0 || phi == NULL)
+  if (reduction_list.elements () == 0 || phi == NULL)
     return NULL;

   tmpred.reduc_phi = phi;
   tmpred.reduc_version = gimple_uid (phi);
-  red = (struct reduction_info *) htab_find (reduction_list, &tmpred);
+  red = reduction_list.find (&tmpred);

   return red;
 }
@@ -222,25 +230,32 @@ struct name_to_copy_elt
 			   value.  */
 };

-/* Equality and hash functions for hashtab code.  */
+/* Name copies hashtable helpers.  */

-static int
-name_to_copy_elt_eq (const void *aa, const void *bb)
+struct name_to_copy_hasher : typed_free_remove <name_to_copy_elt>
 {
-  const struct name_to_copy_elt *a = (const struct name_to_copy_elt *) aa;
-  const struct name_to_copy_elt *b = (const struct name_to_copy_elt *) bb;
+  typedef name_to_copy_elt value_type;
+  typedef name_to_copy_elt compare_type;
+  static inline hashval_t hash (const value_type *);
+  static inline bool equal (const value_type *, const compare_type *);
+};
+
+/* Equality and hash functions for hashtab code.  */

+inline bool
+name_to_copy_hasher::equal (const value_type *a, const compare_type *b)
+{
   return a->version == b->version;
 }

-static hashval_t
-name_to_copy_elt_hash (const void *aa)
+inline hashval_t
+name_to_copy_hasher::hash (const value_type *a)
 {
-  const struct name_to_copy_elt *a = (const struct name_to_copy_elt *) aa;
-
   return (hashval_t) a->version;
 }

+typedef hash_table <name_to_copy_hasher> name_to_copy_table_type;
+
 /* A transformation matrix, which is a self-contained ROWSIZE x COLSIZE
    matrix.  Rather than use floats, we simply keep a single DENOMINATOR that
    represents the denominator for every element in the matrix.  */
@@ -519,15 +534,14 @@ take_address_of (tree obj, tree type, ed
    for reduction described in SLOT, and place it at the preheader of
    the loop described in DATA.  */

-static int
-initialize_reductions (void **slot, void *data)
+int
+initialize_reductions (reduction_info **slot, struct loop *loop)
 {
   tree init, c;
   tree bvar, type, arg;
   edge e;

-  struct reduction_info *const reduc = (struct reduction_info *) *slot;
-  struct loop *loop = (struct loop *) data;
+  struct reduction_info *const reduc = *slot;

   /* Create initialization in preheader:
      reduction_variable = initialization value of reduction.  */
@@ -775,14 +789,14 @@ expr_invariant_in_region_p (edge entry,
    duplicated, storing the copies in DECL_COPIES.  */

 static tree
-separate_decls_in_region_name (tree name, htab_t name_copies,
+separate_decls_in_region_name (tree name, name_to_copy_table_type name_copies,
 			       int_tree_htab_type decl_copies, bool copy_name_p)
 {
   tree copy, var, var_copy;
   unsigned idx, uid, nuid;
   struct int_tree_map ielt, *nielt;
   struct name_to_copy_elt elt, *nelt;
-  void **slot;
+  name_to_copy_elt **slot;
   int_tree_map **dslot;

   if (TREE_CODE (name) != SSA_NAME)
@@ -790,10 +804,10 @@ separate_decls_in_region_name (tree name

   idx = SSA_NAME_VERSION (name);
   elt.version = idx;
-  slot = htab_find_slot_with_hash (name_copies, &elt, idx,
-				   copy_name_p ? INSERT : NO_INSERT);
+  slot = name_copies.find_slot_with_hash (&elt, idx,
+					  copy_name_p ? INSERT : NO_INSERT);
   if (slot && *slot)
-    return ((struct name_to_copy_elt *) *slot)->new_name;
+    return (*slot)->new_name;

   if (copy_name_p)
     {
@@ -853,7 +867,7 @@ separate_decls_in_region_name (tree name

 static void
 separate_decls_in_region_stmt (edge entry, edge exit, gimple stmt,
-			       htab_t name_copies,
+			       name_to_copy_table_type name_copies,
 			       int_tree_htab_type decl_copies)
 {
   use_operand_p use;
@@ -892,7 +906,8 @@ separate_decls_in_region_stmt (edge entr
    replacement decls are stored in DECL_COPIES.  */

 static bool
-separate_decls_in_region_debug (gimple stmt, htab_t name_copies,
+separate_decls_in_region_debug (gimple stmt,
+				name_to_copy_table_type name_copies,
 				int_tree_htab_type decl_copies)
 {
   use_operand_p use;
@@ -900,7 +915,7 @@ separate_decls_in_region_debug (gimple s
   tree var, name;
   struct int_tree_map ielt;
   struct name_to_copy_elt elt;
-  void **slot;
+  name_to_copy_elt **slot;
   int_tree_map **dslot;

   if (gimple_debug_bind_p (stmt))
@@ -928,7 +943,7 @@ separate_decls_in_region_debug (gimple s
       continue;

     elt.version = SSA_NAME_VERSION (name);
-    slot = htab_find_slot_with_hash (name_copies, &elt, elt.version,
NO_INSERT);
+    slot = name_copies.find_slot_with_hash (&elt, elt.version, NO_INSERT);
     if (!slot)
       {