diff options
Diffstat (limited to 'gcc/tree-parloops.c')
| -rw-r--r-- | gcc/tree-parloops.c | 264 |
1 files changed, 142 insertions, 122 deletions
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c index 1729f23..088fc46 100644 --- a/gcc/tree-parloops.c +++ b/gcc/tree-parloops.c @@ -30,6 +30,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-pass.h" #include "langhooks.h" #include "tree-vectorizer.h" +#include "tree-hasher.h" /* This pass tries to distribute iterations of loops into several threads. The implementation is straightforward -- for each loop we test whether its @@ -176,36 +177,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; } @@ -220,25 +229,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. */ @@ -445,11 +461,11 @@ loop_has_blocks_with_irreducible_flag (struct loop *loop) right before GSI. */ static tree -take_address_of (tree obj, tree type, edge entry, htab_t decl_address, - gimple_stmt_iterator *gsi) +take_address_of (tree obj, tree type, edge entry, + int_tree_htab_type decl_address, gimple_stmt_iterator *gsi) { int uid; - void **dslot; + int_tree_map **dslot; struct int_tree_map ielt, *nielt; tree *var_p, name, addr; gimple stmt; @@ -472,7 +488,7 @@ take_address_of (tree obj, tree type, edge entry, htab_t decl_address, on it. */ uid = DECL_UID (TREE_OPERAND (TREE_OPERAND (*var_p, 0), 0)); ielt.uid = uid; - dslot = htab_find_slot_with_hash (decl_address, &ielt, uid, INSERT); + dslot = decl_address.find_slot_with_hash (&ielt, uid, INSERT); if (!*dslot) { if (gsi == NULL) @@ -490,7 +506,7 @@ take_address_of (tree obj, tree type, edge entry, htab_t decl_address, *dslot = nielt; } else - name = ((struct int_tree_map *) *dslot)->to; + name = (*dslot)->to; /* Express the address in terms of the canonical SSA name. */ TREE_OPERAND (*var_p, 0) = name; @@ -517,15 +533,14 @@ take_address_of (tree obj, tree type, edge entry, htab_t decl_address, 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. */ @@ -567,7 +582,7 @@ struct elv_data { struct walk_stmt_info info; edge entry; - htab_t decl_address; + int_tree_htab_type decl_address; gimple_stmt_iterator *gsi; bool changed; bool reset; @@ -657,7 +672,7 @@ eliminate_local_variables_1 (tree *tp, int *walk_subtrees, void *data) static void eliminate_local_variables_stmt (edge entry, gimple_stmt_iterator *gsi, - htab_t decl_address) + int_tree_htab_type decl_address) { struct elv_data dta; gimple stmt = gsi_stmt (*gsi); @@ -709,8 +724,8 @@ eliminate_local_variables (edge entry, edge exit) unsigned i; gimple_stmt_iterator gsi; bool has_debug_stmt = false; - htab_t decl_address = htab_create (10, int_tree_map_hash, int_tree_map_eq, - free); + int_tree_htab_type decl_address; + decl_address.create (10); basic_block entry_bb = entry->src; basic_block exit_bb = exit->dest; @@ -734,7 +749,7 @@ eliminate_local_variables (edge entry, edge exit) if (gimple_debug_bind_p (gsi_stmt (gsi))) eliminate_local_variables_stmt (entry, &gsi, decl_address); - htab_delete (decl_address); + decl_address.dispose (); body.release (); } @@ -773,25 +788,25 @@ expr_invariant_in_region_p (edge entry, edge exit, tree expr) duplicated, storing the copies in DECL_COPIES. */ static tree -separate_decls_in_region_name (tree name, - htab_t name_copies, htab_t decl_copies, - bool copy_name_p) +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, **dslot; + name_to_copy_elt **slot; + int_tree_map **dslot; if (TREE_CODE (name) != SSA_NAME) return 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) { @@ -814,7 +829,7 @@ separate_decls_in_region_name (tree name, uid = DECL_UID (var); ielt.uid = uid; - dslot = htab_find_slot_with_hash (decl_copies, &ielt, uid, INSERT); + dslot = decl_copies.find_slot_with_hash (&ielt, uid, INSERT); if (!*dslot) { var_copy = create_tmp_var (TREE_TYPE (var), get_name (var)); @@ -828,7 +843,7 @@ separate_decls_in_region_name (tree name, it again. */ nuid = DECL_UID (var_copy); ielt.uid = nuid; - dslot = htab_find_slot_with_hash (decl_copies, &ielt, nuid, INSERT); + dslot = decl_copies.find_slot_with_hash (&ielt, nuid, INSERT); gcc_assert (!*dslot); nielt = XNEW (struct int_tree_map); nielt->uid = nuid; @@ -851,7 +866,8 @@ separate_decls_in_region_name (tree name, static void separate_decls_in_region_stmt (edge entry, edge exit, gimple stmt, - htab_t name_copies, htab_t decl_copies) + name_to_copy_table_type name_copies, + int_tree_htab_type decl_copies) { use_operand_p use; def_operand_p def; @@ -889,15 +905,17 @@ separate_decls_in_region_stmt (edge entry, edge exit, gimple stmt, replacement decls are stored in DECL_COPIES. */ static bool -separate_decls_in_region_debug (gimple stmt, htab_t name_copies, - htab_t decl_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; ssa_op_iter oi; tree var, name; struct int_tree_map ielt; struct name_to_copy_elt elt; - void **slot, **dslot; + name_to_copy_elt **slot; + int_tree_map **dslot; if (gimple_debug_bind_p (stmt)) var = gimple_debug_bind_get_var (stmt); @@ -909,7 +927,7 @@ separate_decls_in_region_debug (gimple stmt, htab_t name_copies, return true; gcc_assert (DECL_P (var) && SSA_VAR_P (var)); ielt.uid = DECL_UID (var); - dslot = htab_find_slot_with_hash (decl_copies, &ielt, ielt.uid, NO_INSERT); + dslot = decl_copies.find_slot_with_hash (&ielt, ielt.uid, NO_INSERT); if (!dslot) return true; if (gimple_debug_bind_p (stmt)) @@ -924,7 +942,7 @@ separate_decls_in_region_debug (gimple stmt, htab_t name_copies, 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) { gimple_debug_bind_reset_value (stmt); @@ -932,7 +950,7 @@ separate_decls_in_region_debug (gimple stmt, htab_t name_copies, break; } - SET_USE (use, ((struct name_to_copy_elt *) *slot)->new_name); + SET_USE (use, (*slot)->new_name); } return false; @@ -941,12 +959,11 @@ separate_decls_in_region_debug (gimple stmt, htab_t name_copies, /* Callback for htab_traverse. Adds a field corresponding to the reduction specified in SLOT. The type is passed in DATA. */ -static int -add_field_for_reduction (void **slot, void *data) +int +add_field_for_reduction (reduction_info **slot, tree type) { - struct reduction_info *const red = (struct reduction_info *) *slot; - tree const type = (tree) data; + struct reduction_info *const red = *slot; tree var = SSA_NAME_VAR (gimple_assign_lhs (red->reduc_stmt)); tree field = build_decl (gimple_location (red->reduc_stmt), FIELD_DECL, DECL_NAME (var), TREE_TYPE (var)); @@ -961,11 +978,10 @@ add_field_for_reduction (void **slot, void *data) /* Callback for htab_traverse. Adds a field corresponding to a ssa name described in SLOT. The type is passed in DATA. */ -static int -add_field_for_name (void **slot, void *data) +int +add_field_for_name (name_to_copy_elt **slot, tree type) { - struct name_to_copy_elt *const elt = (struct name_to_copy_elt *) *slot; - tree type = (tree) data; + struct name_to_copy_elt *const elt = *slot; tree name = ssa_name (elt->version); tree field = build_decl (UNKNOWN_LOCATION, FIELD_DECL, SSA_NAME_IDENTIFIER (name), @@ -984,11 +1000,10 @@ add_field_for_name (void **slot, void *data) The phi's result will be stored in NEW_PHI field of the reduction's data structure. */ -static int -create_phi_for_local_result (void **slot, void *data) +int +create_phi_for_local_result (reduction_info **slot, struct loop *loop) { - struct reduction_info *const reduc = (struct reduction_info *) *slot; - const struct loop *const loop = (const struct loop *) data; + struct reduction_info *const reduc = *slot; edge e; gimple new_phi; basic_block store_bb; @@ -1034,11 +1049,10 @@ struct clsn_data DATA annotates the place in memory the atomic operation relates to, and the basic block it needs to be generated in. */ -static int -create_call_for_reduction_1 (void **slot, void *data) +int +create_call_for_reduction_1 (reduction_info **slot, struct clsn_data *clsn_data) { - struct reduction_info *const reduc = (struct reduction_info *) *slot; - struct clsn_data *const clsn_data = (struct clsn_data *) data; + struct reduction_info *const reduc = *slot; gimple_stmt_iterator gsi; tree type = TREE_TYPE (PHI_RESULT (reduc->reduc_phi)); tree load_struct; @@ -1087,23 +1101,24 @@ create_call_for_reduction_1 (void **slot, void *data) LD_ST_DATA describes the shared data structure where shared data is stored in and loaded from. */ static void -create_call_for_reduction (struct loop *loop, htab_t reduction_list, +create_call_for_reduction (struct loop *loop, + reduction_info_table_type reduction_list, struct clsn_data *ld_st_data) { - htab_traverse (reduction_list, create_phi_for_local_result, loop); + reduction_list.traverse <struct loop *, create_phi_for_local_result> (loop); /* Find the fallthru edge from GIMPLE_OMP_CONTINUE. */ ld_st_data->load_bb = FALLTHRU_EDGE (loop->latch)->dest; - htab_traverse (reduction_list, create_call_for_reduction_1, ld_st_data); + reduction_list + .traverse <struct clsn_data *, create_call_for_reduction_1> (ld_st_data); } /* Callback for htab_traverse. Loads the final reduction value at the join point of all threads, and inserts it in the right place. */ -static int -create_loads_for_reductions (void **slot, void *data) +int +create_loads_for_reductions (reduction_info **slot, struct clsn_data *clsn_data) { - struct reduction_info *const red = (struct reduction_info *) *slot; - struct clsn_data *const clsn_data = (struct clsn_data *) data; + struct reduction_info *const red = *slot; gimple stmt; gimple_stmt_iterator gsi; tree type = TREE_TYPE (gimple_assign_lhs (red->reduc_stmt)); @@ -1137,7 +1152,7 @@ create_loads_for_reductions (void **slot, void *data) REDUCTION_LIST describes the list of reductions that the loads should be generated for. */ static void -create_final_loads_for_reduction (htab_t reduction_list, +create_final_loads_for_reduction (reduction_info_table_type reduction_list, struct clsn_data *ld_st_data) { gimple_stmt_iterator gsi; @@ -1151,7 +1166,8 @@ create_final_loads_for_reduction (htab_t reduction_list, gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); SSA_NAME_DEF_STMT (ld_st_data->load) = stmt; - htab_traverse (reduction_list, create_loads_for_reductions, ld_st_data); + reduction_list + .traverse <struct clsn_data *, create_loads_for_reductions> (ld_st_data); } @@ -1161,11 +1177,10 @@ create_final_loads_for_reduction (htab_t reduction_list, The reduction is specified in SLOT. The store information is passed in DATA. */ -static int -create_stores_for_reduction (void **slot, void *data) +int +create_stores_for_reduction (reduction_info **slot, struct clsn_data *clsn_data) { - struct reduction_info *const red = (struct reduction_info *) *slot; - struct clsn_data *const clsn_data = (struct clsn_data *) data; + struct reduction_info *const red = *slot; tree t; gimple stmt; gimple_stmt_iterator gsi; @@ -1183,11 +1198,11 @@ create_stores_for_reduction (void **slot, void *data) store to a field of STORE in STORE_BB for the ssa name and its duplicate specified in SLOT. */ -static int -create_loads_and_stores_for_name (void **slot, void *data) +int +create_loads_and_stores_for_name (name_to_copy_elt **slot, + struct clsn_data *clsn_data) { - struct name_to_copy_elt *const elt = (struct name_to_copy_elt *) *slot; - struct clsn_data *const clsn_data = (struct clsn_data *) data; + struct name_to_copy_elt *const elt = *slot; tree t; gimple stmt; gimple_stmt_iterator gsi; @@ -1244,17 +1259,18 @@ create_loads_and_stores_for_name (void **slot, void *data) in LOOP. */ static void -separate_decls_in_region (edge entry, edge exit, htab_t reduction_list, +separate_decls_in_region (edge entry, edge exit, + reduction_info_table_type reduction_list, tree *arg_struct, tree *new_arg_struct, struct clsn_data *ld_st_data) { basic_block bb1 = split_edge (entry); basic_block bb0 = single_pred (bb1); - htab_t name_copies = htab_create (10, name_to_copy_elt_hash, - name_to_copy_elt_eq, free); - htab_t decl_copies = htab_create (10, int_tree_map_hash, int_tree_map_eq, - free); + name_to_copy_table_type name_copies; + name_copies.create (10); + int_tree_htab_type decl_copies; + decl_copies.create (10); unsigned i; tree type, type_name, nvar; gimple_stmt_iterator gsi; @@ -1320,7 +1336,7 @@ separate_decls_in_region (edge entry, edge exit, htab_t reduction_list, body.release (); - if (htab_elements (name_copies) == 0 && htab_elements (reduction_list) == 0) + if (name_copies.elements () == 0 && reduction_list.elements () == 0) { /* It may happen that there is nothing to copy (if there are only loop carried and external variables in the loop). */ @@ -1336,12 +1352,11 @@ separate_decls_in_region (edge entry, edge exit, htab_t reduction_list, type); TYPE_NAME (type) = type_name; - htab_traverse (name_copies, add_field_for_name, type); - if (reduction_list && htab_elements (reduction_list) > 0) + name_copies.traverse <tree, add_field_for_name> (type); + if (reduction_list.is_created () && reduction_list.elements () > 0) { /* Create the fields for reductions. */ - htab_traverse (reduction_list, add_field_for_reduction, - type); + reduction_list.traverse <tree, add_field_for_reduction> (type); } layout_type (type); @@ -1355,15 +1370,17 @@ separate_decls_in_region (edge entry, edge exit, htab_t reduction_list, ld_st_data->store_bb = bb0; ld_st_data->load_bb = bb1; - htab_traverse (name_copies, create_loads_and_stores_for_name, - ld_st_data); + name_copies + .traverse <struct clsn_data *, create_loads_and_stores_for_name> + (ld_st_data); /* Load the calculation from memory (after the join of the threads). */ - if (reduction_list && htab_elements (reduction_list) > 0) + if (reduction_list.is_created () && reduction_list.elements () > 0) { - htab_traverse (reduction_list, create_stores_for_reduction, - ld_st_data); + reduction_list + .traverse <struct clsn_data *, create_stores_for_reduction> + (ld_st_data); clsn_data.load = make_ssa_name (nvar, NULL); clsn_data.load_bb = exit->dest; clsn_data.store = ld_st_data->store; @@ -1371,8 +1388,8 @@ separate_decls_in_region (edge entry, edge exit, htab_t reduction_list, } } - htab_delete (decl_copies); - htab_delete (name_copies); + decl_copies.dispose (); + name_copies.dispose (); } /* Bitmap containing uids of functions created by parallelization. We cannot @@ -1461,7 +1478,9 @@ create_loop_fn (location_t loc) REDUCTION_LIST describes the reductions in LOOP. */ static void -transform_to_exit_first_loop (struct loop *loop, htab_t reduction_list, tree nit) +transform_to_exit_first_loop (struct loop *loop, + reduction_info_table_type reduction_list, + tree nit) { basic_block *bbs, *nbbs, ex_bb, orig_header; unsigned n; @@ -1530,7 +1549,7 @@ transform_to_exit_first_loop (struct loop *loop, htab_t reduction_list, tree nit PHI_RESULT of this phi is the resulting value of the reduction variable when exiting the loop. */ - if (htab_elements (reduction_list) > 0) + if (reduction_list.elements () > 0) { struct reduction_info *red; @@ -1708,7 +1727,7 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data, REDUCTION_LIST describes the reductions existent in the LOOP. */ static void -gen_parallel_loop (struct loop *loop, htab_t reduction_list, +gen_parallel_loop (struct loop *loop, reduction_info_table_type reduction_list, unsigned n_threads, struct tree_niter_desc *niter) { loop_iterator li; @@ -1834,8 +1853,8 @@ gen_parallel_loop (struct loop *loop, htab_t reduction_list, transform_to_exit_first_loop (loop, reduction_list, nit); /* Generate initializations for reductions. */ - if (htab_elements (reduction_list) > 0) - htab_traverse (reduction_list, initialize_reductions, loop); + if (reduction_list.elements () > 0) + reduction_list.traverse <struct loop *, initialize_reductions> (loop); /* Eliminate the references to local variables from the loop. */ gcc_assert (single_exit (loop)); @@ -1855,7 +1874,7 @@ gen_parallel_loop (struct loop *loop, htab_t reduction_list, loc = gimple_location (cond_stmt); parallel_head = create_parallel_loop (loop, create_loop_fn (loc), arg_struct, new_arg_struct, n_threads, loc); - if (htab_elements (reduction_list) > 0) + if (reduction_list.elements () > 0) create_call_for_reduction (loop, reduction_list, &clsn_data); scev_reset (); @@ -1902,9 +1921,10 @@ loop_has_vector_phi_nodes (struct loop *loop ATTRIBUTE_UNUSED) and PHI, insert it to the REDUCTION_LIST. */ static void -build_new_reduction (htab_t reduction_list, gimple reduc_stmt, gimple phi) +build_new_reduction (reduction_info_table_type reduction_list, + gimple reduc_stmt, gimple phi) { - PTR *slot; + reduction_info **slot; struct reduction_info *new_reduction; gcc_assert (reduc_stmt); @@ -1923,16 +1943,16 @@ build_new_reduction (htab_t reduction_list, gimple reduc_stmt, gimple phi) new_reduction->reduc_phi = phi; new_reduction->reduc_version = SSA_NAME_VERSION (gimple_phi_result (phi)); new_reduction->reduction_code = gimple_assign_rhs_code (reduc_stmt); - slot = htab_find_slot (reduction_list, new_reduction, INSERT); + slot = reduction_list.find_slot (new_reduction, INSERT); *slot = new_reduction; } /* Callback for htab_traverse. Sets gimple_uid of reduc_phi stmts. */ -static int -set_reduc_phi_uids (void **slot, void *data ATTRIBUTE_UNUSED) +int +set_reduc_phi_uids (reduction_info **slot, void *data ATTRIBUTE_UNUSED) { - struct reduction_info *const red = (struct reduction_info *) *slot; + struct reduction_info *const red = *slot; gimple_set_uid (red->reduc_phi, red->reduc_version); return 1; } @@ -1940,7 +1960,7 @@ set_reduc_phi_uids (void **slot, void *data ATTRIBUTE_UNUSED) /* Detect all reductions in the LOOP, insert them into REDUCTION_LIST. */ static void -gather_scalar_reductions (loop_p loop, htab_t reduction_list) +gather_scalar_reductions (loop_p loop, reduction_info_table_type reduction_list) { gimple_stmt_iterator gsi; loop_vec_info simple_loop_info; @@ -1972,7 +1992,7 @@ gather_scalar_reductions (loop_p loop, htab_t reduction_list) /* As gimple_uid is used by the vectorizer in between vect_analyze_loop_form and destroy_loop_vec_info, we can set gimple_uid of reduc_phi stmts only now. */ - htab_traverse (reduction_list, set_reduc_phi_uids, NULL); + reduction_list.traverse <void *, set_reduc_phi_uids> (NULL); } /* Try to initialize NITER for code generation part. */ @@ -2001,7 +2021,8 @@ try_get_loop_niter (loop_p loop, struct tree_niter_desc *niter) REDUCTION_LIST describes the reductions. */ static bool -try_create_reduction_list (loop_p loop, htab_t reduction_list) +try_create_reduction_list (loop_p loop, + reduction_info_table_type reduction_list) { edge exit = single_dom_exit (loop); gimple_stmt_iterator gsi; @@ -2032,7 +2053,7 @@ try_create_reduction_list (loop_p loop, htab_t reduction_list) fprintf (dump_file, " checking if it a part of reduction pattern: \n"); } - if (htab_elements (reduction_list) == 0) + if (reduction_list.elements () == 0) { if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, @@ -2106,7 +2127,7 @@ parallelize_loops (void) struct loop *loop; struct tree_niter_desc niter_desc; loop_iterator li; - htab_t reduction_list; + reduction_info_table_type reduction_list; struct obstack parloop_obstack; HOST_WIDE_INT estimated; LOC loop_loc; @@ -2118,13 +2139,12 @@ parallelize_loops (void) return false; gcc_obstack_init (&parloop_obstack); - reduction_list = htab_create (10, reduction_info_hash, - reduction_info_eq, free); + reduction_list.create (10); init_stmt_vec_info_vec (); FOR_EACH_LOOP (li, loop, 0) { - htab_empty (reduction_list); + reduction_list.empty (); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Trying loop %d as candidate\n",loop->num); @@ -2204,7 +2224,7 @@ parallelize_loops (void) } free_stmt_vec_info_vec (); - htab_delete (reduction_list); + reduction_list.dispose (); obstack_free (&parloop_obstack, NULL); /* Parallelization will cause new function calls to be inserted through |