From 4a8fb1a1de7c34fc788ccca21f3a15980bbce093 Mon Sep 17 00:00:00 2001 From: Lawrence Crowl Date: Fri, 26 Apr 2013 00:28:35 +0000 Subject: This patch is the main part of a consolodation of the hash_table patches to the... This patch is the main part of a consolodation of the hash_table patches to the cxx-conversion branch for files not under gcc/config. Update various hash tables from htab_t to hash_table. Modify types and calls to match. * tree-parloops.c'reduction * tree-parloops.c'name_to_copy Fold reduction_info_hash and reduction_info_eq into new struct reduction_hasher. Fold name_to_copy_elt_eq and name_to_copy_elt_hash into new struct name_to_copy_hasher. * trans-mem.c'tm_log Fold tm_log_hash, tm_log_eq, tm_log_free into new struct log_entry_hasher. * trans-mem.c'tm_memopt_value_numbers Fold tm_memop_hash, tm_memop_eq into new struct tm_memop_hasher. * tree-ssa-strlen.c'decl_to_stridxlist_htab Fold decl_to_stridxlist_hash into new struct stridxlist_hasher. * tree-ssa-loop-ivopts.c'ivopts_data::inv_expr_tab Fold htab_inv_expr_hash and htab_inv_expr_eq into new struct iv_inv_expr_hasher. * tree-ssa-uncprop.c'equiv Equiv renamed to val_ssa_equiv because of name ambiguity with local variables. Fold equiv_hash, equiv_eq and equiv_free into new struct val_ssa_equiv_hasher. Renamed variables equiv_hash_elt to an_equiv_elt because of name ambiguity with struct type. Changed equiv_hash_elt_p to an_equiv_elt_p to match. * tree-ssa-phiopt.c'seen_ssa_names Fold name_to_bb_hash and name_to_bb_eq into new struct ssa_names_hasher. * tree-ssa-structalias.c'pointer_equiv_class_table * tree-ssa-structalias.c'location_equiv_class_table Fold equiv_class_label_hash and equiv_class_label_eq into new struct equiv_class_hasher. * tree-ssa-structalias.c'shared_bitmap_table Fold shared_bitmap_hash and shared_bitmap_eq into new struct shared_bitmap_hasher. * tree-ssa-live.c'var_map_base_init::tree_to_index New struct tree_int_map_hasher. * tree-sra.c'candidates Fold uid_decl_map_hash and uid_decl_map_eq into new struct uid_decl_hasher. This change moves the definitions from tree-ssa.c into tree-sra.c and removes the declarations from tree-flow.h tree-browser.c Remove stale declaration of removed TB_parent_eq. Fix template parameter for base class to match value_type. gimple.h Use gimplify_hasher::hash rather than gimple_tree_hash in the assertion check. Change return values to match return type. (I.e. no conversions.) * graphite-clast-to-gimple.c'ivs_params::newivs_index * graphite-clast-to-gimple.c'ivs_params::params_index * graphite-clast-to-gimple.c'print_generated_program::params_index * graphite-clast-to-gimple.c'gloog::newivs_index * graphite-clast-to-gimple.c'gloog::params_index * graphite.c graphite_transform_loops::bb_pbb_mapping * sese.c copy_bb_and_scalar_dependences::rename_map Move hash table declarations to a new graphite-htab.h, because they are used in few places. Remove unused: htab_t scop::original_pddrs SCOP_ORIGINAL_PDDRS Remove unused: insert_loop_close_phis insert_guard_phis debug_ivtype_map ivtype_map_elt_info new_ivtype_map_elt * gimplify.c'gimplify_ctx::temp_htab Move struct gimple_temp_hash_elt and struct gimplify_ctx to a new gimplify-ctx.h, because they are used few places. * cselib.c'cselib_hash_table * gcse.c'pre_ldst_table * gimple-ssa-strength-reduction.c'base_cand_map * haifa-sched.c'delay_htab * haifa-sched.c'delay_htab_i2 * ira-color.c'allocno_hard_regs_htab * ira-costs.c'cost_classes_htab * loop-invariant.c'merge_identical_invariants::eq * loop-iv.c'bivs * loop-unroll.c'opt_info::insns_to_split * loop-unroll.c'opt_info::insns_with_var_to_expand * passes.c'name_to_pass_map * plugin.c'event_tab * postreload-gcse.c'expr_table * store-motion.c'store_motion_mems_table * tree-cfg.c'discriminator_per_locus * tree-scalar-evolution.c'resolve_mixers::cache * tree-ssa-dom.c'avail_exprs Remove unused: dse.c bitmap clear_alias_sets dse.c bitmap disqualified_clear_alias_sets dse.c alloc_pool clear_alias_mode_pool dse.c dse_step2_spill dse.c dse_step5_spill graphds.h htab_t graph::indices * attribs.c'scoped_attributes::attribute_hash * bitmap.c'bitmap_desc_hash * dwarf2cfi.c'trace_index * dwarf2out.c'break_out_includes::cu_hash_table * dwarf2out.c'copy_decls_for_unworthy_types::decl_table * dwarf2out.c'optimize_external_refs::map * dwarf2out.c'output_comp_unit::extern_map * dwarf2out.c'output_comdat_type_unit::extern_map * dwarf2out.c'output_macinfo::macinfo_htab * dwarf2out.c'optimize_location_lists::htab * dwarf2out.c'dwarf2out_finish::comdat_type_table * except.c'ehspec_hash_type * except.c'assign_filter_values::ttypes * except.c'assign_filter_values::ehspec * except.c'sjlj_assign_call_site_values::ar_hash * except.c'convert_to_eh_region_ranges::ar_hash * trans-mem.c'tm_new_mem_hash * tree-browser.c'TB_up_ht * tree-eh.c'finally_tree Move the declaration of hash_table alloc_pool_hash in alloc-pool.c to after the method definitions for its parameter class. * ggc-common.c'loc_hash * ggc-common.c'ptr_hash Add a new hash_table method elements_with_deleted to meet the needs of gcc-common.c. Correct many methods with parameter types compare_type to the correct value_type. (Correct code was unlikely to notice the change, but incorrect code will.) * tree-complex.c'complex_variable_components * tree-parloops.c'eliminate_local_variables_stmt::decl_address * tree-parloops.c'separate_decls_in_region::decl_copies Move hash table declarations to a new tree-hasher.h, to resolve compilation dependences and because they are used in few places. * lto-streamer.h'output_block::string_hash_table * lto-streamer-in.c'file_name_hash_table * lto-streamer.c'tree_htab The struct string_slot moves from data-streamer.h to lto-streamer.h to resolve compilation dependences. Tested on x86_64. Index: gcc/ChangeLog 2013-04-25 Lawrence Crowl * Makefile.in: Update as needed below. * alloc-pool.c (static hash_table alloc_pool_hash): Move declaration to after the type's method definitons. * attribs.c (htab_t scoped_attributes::attribute_hash): Change type to hash_table. Update dependent calls and types. * bitmap.c (htab_t bitmap_desc_hash): Change type to hash_table. Update dependent calls and types. * cselib.c (htab_t cselib_hash_table): Change type to hash_table. Update dependent calls and types. * data-streamer.h (struct string_slot): Move to lto-streamer.h. (hash_string_slot_node): Move implementation into lto-streamer.h struct string_slot_hasher. (eq_string_slot_node): Likewise. * data-streamer-out.c: Update output_block::string_hash_table dependent calls and types. * dwarf2cfi.c (htab_t trace_index): Change type to hash_table. Update dependent calls and types. * dwarf2out.c (htab_t break_out_includes::cu_hash_table): Change type to hash_table. Update dependent calls and types. (htab_t copy_decls_for_unworthy_types::decl_table): Likewise. (htab_t optimize_external_refs::map): Likewise. (htab_t output_comp_unit::extern_map): Likewise. (htab_t output_comdat_type_unit::extern_map): Likewise. (htab_t output_macinfo::macinfo_htab): Likewise. (htab_t optimize_location_lists::htab): Likewise. (htab_t dwarf2out_finish::comdat_type_table): Likewise. * except.c (htab_t ehspec_hash_type): Change type to hash_table. Update dependent calls and types. (assign_filter_values::ttypes): Likewise. (assign_filter_values::ehspec): Likewise. (sjlj_assign_call_site_values::ar_hash): Likewise. (convert_to_eh_region_ranges::ar_hash): Likewise. * gcse.c (htab_t pre_ldst_table): Change type to hash_table. Update dependent calls and types. * ggc-common.c (htab_t saving_htab): Change type to hash_table. Update dependent calls and types. (htab_t loc_hash): Likewise. (htab_t ptr_hash): Likewise. (call_count): Rename ggc_call_count. (call_alloc): Rename ggc_call_alloc. (loc_descriptor): Rename make_loc_descriptor. (add_statistics): Rename ggc_add_statistics. * ggc-common.c (saving_htab): Change type to hash_table. Update dependent calls and types. * gimple.h (struct gimplify_ctx): Move to gimplify-ctx.h. (push_gimplify_context): Likewise. (pop_gimplify_context): Likewise. (struct gimple_temp_hash_elt): Added. (struct gimplify_hasher): Likewise. (struct gimplify_ctx.temp_htab): Change type to hash_table. Update dependent calls and types. * gimple-fold.c: Include gimplify-ctx.h. * gimple-ssa-strength-reduction.c (htab_t base_cand_map): Change type to hash_table. Update dependent calls and types. (base_cand_dump_callback): Rename to ssa_base_cand_dump_callback to avoid potential global name collision. * gimplify.c: Include gimplify-ctx.h. (struct gimple_temp_hash_elt): Move to gimplify-ctx.h. (htab_t gimplify_ctx::temp_htab): Update dependent calls and types for new type hash_table. (gimple_tree_hash): Move into gimplify_hasher in gimplify-ctx.h. (gimple_tree_eq): Move into gimplify_hasher in gimplify-ctx.h. * gimplify-ctx.h: New. (struct gimple_temp_hash_elt): Move from gimplify.c. (class gimplify_hasher): New. (struct gimplify_ctx): Move from gimple.h. (htab_t gimplify_ctx::temp_htab): Change type to hash_table. Update dependent calls and types. * graphite-clast-to-gimple.c: Include graphite-htab.h. (htab_t ivs_params::newivs_index): Change type to hash_table. Update dependent calls and types. (htab_t ivs_params::params_index): Likewise. (htab_t print_generated_program::params_index): Likewise. (htab_t gloog::newivs_index): Likewise. (htab_t gloog::params_index): Likewise. * graphite.c: Include graphite-htab.h. 4htab_t graphite_transform_loops::bb_pbb_mapping): Change type to hash_table. Update dependent calls and types. * graphite-clast-to-gimple.h: (extern gloog) Move to graphite-htab.h. (bb_pbb_map_hash): Fold into bb_pbb_htab_type in graphite-htab.h. (eq_bb_pbb_map): Fold into bb_pbb_htab_type in graphite-htab.h. * graphite-dependences.c: Include graphite-htab.h. (loop_is_parallel_p): Change hash table type of parameter. * graphite-htab.h: New. (typedef hash_table bb_pbb_htab_type): New. (extern find_pbb_via_hash): Move from graphite-poly.h. (extern loop_is_parallel_p): Move from graphite-poly.h. (extern get_loop_body_pbbs): Move from graphite-poly.h. * graphite-poly.h (extern find_pbb_via_hash): Move to graphite-htab.h. (extern loop_is_parallel_p): Move to graphite-htab.h. (extern get_loop_body_pbbs): Move to graphite-htab.h. * haifa-sched.c (htab_t delay_htab): Change type to hash_table. Update dependent calls and types. (htab_t delay_htab_i2): Likewise. * ira-color.c (htab_t allocno_hard_regs_htab): Change type to hash_table. Update dependent calls and types. * ira-costs.c (htab_t cost_classes_htab): Change type to hash_table. Update dependent calls and types. * loop-invariant.c (htab_t merge_identical_invariants::eq): Change type to hash_table. Update dependent calls and types. * loop-iv.c (htab_t bivs): Change type to hash_table. Update dependent calls and types. * loop-unroll.c (htab_t opt_info::insns_to_split): Change type to hash_table. Update dependent calls and types. (htab_t opt_info::insns_with_var_to_expand): Likewise. * lto-streamer.h (struct string_slot): Move from data-streamer.h (struct string_slot_hasher): New. (htab_t output_block::string_hash_table): Change type to hash_table. Update dependent calls and types. * lto-streamer-in.c (freeing_string_slot_hasher): New. (htab_t file_name_hash_table): Change type to hash_table. Update dependent calls and types. * lto-streamer-out.c: Update output_block::string_hash_table dependent calls and types. * lto-streamer.c (htab_t tree_htab): Change type to hash_table. Update dependent calls and types. * omp-low.c: Include gimplify-ctx.h. * passes.c (htab_t name_to_pass_map): Change type to hash_table. Update dependent calls and types. (pass_traverse): Rename to passes_pass_traverse. * plugin.c (htab_t event_tab): Change type to hash_table. Update dependent calls and types. * postreload-gcse.c (htab_t expr_table): Change type to hash_table. Update dependent calls and types. (dump_hash_table_entry): Rename dump_expr_hash_table_entry. * sese.c (debug_rename_map_1): Make extern. (htab_t copy_bb_and_scalar_dependences::rename_map): Change type to hash_table. Update dependent calls and types. * sese.h (extern debug_rename_map): Move to .c file. * store-motion.c (htab_t store_motion_mems_table): Change type to hash_table. Update dependent calls and types. * trans-mem.c (htab_t tm_new_mem_hash): Change type to hash_table. Update dependent calls and types. * tree-browser.c (htab_t TB_up_ht): Change type to hash_table. Update dependent calls and types. * tree-cfg.c (htab_t discriminator_per_locus): Change type to hash_table. Update dependent calls and types. * tree-complex.c: Include tree-hasher.h (htab_t complex_variable_components): Change type to hash_table. Update dependent calls and types. * tree-eh.c (htab_t finally_tree): Change type to hash_table. Update dependent calls and types. * tree-flow.h (extern int_tree_map_hash): Moved into tree-hasher struct int_tree_hasher. (extern int_tree_map_eq): Likewise. (uid_decl_map_hash): Removed. (extern decl_tree_map_eq): Likewise. * tree-hasher.h: New. (struct int_tree_hasher): New. (typedef int_tree_htab_type): New. * tree-inline.c: Include gimplify-ctx.h. * tree-mudflap.c: Include gimplify-ctx.h. * tree-parloops.c: Include tree-hasher.h. (htab_t eliminate_local_variables_stmt::decl_address): Change type to hash_table. Update dependent calls and types. (htab_t separate_decls_in_region::decl_copies): Likewise. * tree-scalar-evolution.c (htab_t resolve_mixers::cache): Change type to hash_table. Update dependent calls and types. * tree-sra.c (candidates): Change type to hash_table. Update dependent calls and types. * tree-ssa.c (int_tree_map_eq): Moved into struct int_tree_hasher in tree-flow.h. (int_tree_map_hash): Likewise. * tree-ssa-dom.c (htab_t avail_exprs): Change type to hash_table. Update dependent calls and types. * tree-ssa-live.c (var_map_base_init::tree_to_index): Change type to hash_table. Update dependent calls and types. * tree-ssa-loop-ivopts.c (struct ivopts_data.inv_expr_tab): Change type to hash_table. Update dependent calls and types. * tree-ssa-phiopt.c (seen_ssa_names): Change type to hash_table. Update dependent calls and types. * tree-ssa-strlen.c (decl_to_stridxlist_htab): Change type to hash_table. Update dependent calls and types. * tree-ssa-uncprop.c (equiv): Change type to hash_table. Update dependent calls and types. From-SVN: r198329 --- gcc/haifa-sched.c | 162 ++++++++++++++++++++++++++++-------------------------- 1 file changed, 85 insertions(+), 77 deletions(-) (limited to 'gcc/haifa-sched.c') diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c index 16094b2..15ddedb 100644 --- a/gcc/haifa-sched.c +++ b/gcc/haifa-sched.c @@ -145,7 +145,7 @@ along with GCC; see the file COPYING3. If not see #include "cfgloop.h" #include "ira.h" #include "emit-rtl.h" /* FIXME: Can go away once crtl is moved to rtl.h. */ -#include "hashtab.h" +#include "hash-table.h" #include "dumpfile.h" #ifdef INSN_SCHEDULING @@ -581,22 +581,72 @@ struct delay_pair int stages; }; +/* Helpers for delay hashing. */ + +struct delay_i1_hasher : typed_noop_remove +{ + typedef delay_pair value_type; + typedef void compare_type; + static inline hashval_t hash (const value_type *); + static inline bool equal (const value_type *, const compare_type *); +}; + +/* Returns a hash value for X, based on hashing just I1. */ + +inline hashval_t +delay_i1_hasher::hash (const value_type *x) +{ + return htab_hash_pointer (x->i1); +} + +/* Return true if I1 of pair X is the same as that of pair Y. */ + +inline bool +delay_i1_hasher::equal (const value_type *x, const compare_type *y) +{ + return x->i1 == y; +} + +struct delay_i2_hasher : typed_free_remove +{ + typedef delay_pair value_type; + typedef void compare_type; + static inline hashval_t hash (const value_type *); + static inline bool equal (const value_type *, const compare_type *); +}; + +/* Returns a hash value for X, based on hashing just I2. */ + +inline hashval_t +delay_i2_hasher::hash (const value_type *x) +{ + return htab_hash_pointer (x->i2); +} + +/* Return true if I2 of pair X is the same as that of pair Y. */ + +inline bool +delay_i2_hasher::equal (const value_type *x, const compare_type *y) +{ + return x->i2 == y; +} + /* Two hash tables to record delay_pairs, one indexed by I1 and the other indexed by I2. */ -static htab_t delay_htab; -static htab_t delay_htab_i2; +static hash_table delay_htab; +static hash_table delay_htab_i2; /* Called through htab_traverse. Walk the hashtable using I2 as index, and delete all elements involving an UID higher than that pointed to by *DATA. */ -static int -htab_i2_traverse (void **slot, void *data) +int +haifa_htab_i2_traverse (delay_pair **slot, int *data) { - int maxuid = *(int *)data; - struct delay_pair *p = *(struct delay_pair **)slot; + int maxuid = *data; + struct delay_pair *p = *slot; if (INSN_UID (p->i2) >= maxuid || INSN_UID (p->i1) >= maxuid) { - htab_clear_slot (delay_htab_i2, slot); + delay_htab_i2.clear_slot (slot); } return 1; } @@ -604,16 +654,15 @@ htab_i2_traverse (void **slot, void *data) /* Called through htab_traverse. Walk the hashtable using I2 as index, and delete all elements involving an UID higher than that pointed to by *DATA. */ -static int -htab_i1_traverse (void **slot, void *data) +int +haifa_htab_i1_traverse (delay_pair **pslot, int *data) { - int maxuid = *(int *)data; - struct delay_pair **pslot = (struct delay_pair **)slot; + int maxuid = *data; struct delay_pair *p, *first, **pprev; if (INSN_UID ((*pslot)->i1) >= maxuid) { - htab_clear_slot (delay_htab, slot); + delay_htab.clear_slot (pslot); return 1; } pprev = &first; @@ -627,7 +676,7 @@ htab_i1_traverse (void **slot, void *data) } *pprev = NULL; if (first == NULL) - htab_clear_slot (delay_htab, slot); + delay_htab.clear_slot (pslot); else *pslot = first; return 1; @@ -638,38 +687,8 @@ htab_i1_traverse (void **slot, void *data) void discard_delay_pairs_above (int max_uid) { - htab_traverse (delay_htab, htab_i1_traverse, &max_uid); - htab_traverse (delay_htab_i2, htab_i2_traverse, &max_uid); -} - -/* Returns a hash value for X (which really is a delay_pair), based on - hashing just I1. */ -static hashval_t -delay_hash_i1 (const void *x) -{ - return htab_hash_pointer (((const struct delay_pair *) x)->i1); -} - -/* Returns a hash value for X (which really is a delay_pair), based on - hashing just I2. */ -static hashval_t -delay_hash_i2 (const void *x) -{ - return htab_hash_pointer (((const struct delay_pair *) x)->i2); -} - -/* Return nonzero if I1 of pair X is the same as that of pair Y. */ -static int -delay_i1_eq (const void *x, const void *y) -{ - return ((const struct delay_pair *) x)->i1 == y; -} - -/* Return nonzero if I2 of pair X is the same as that of pair Y. */ -static int -delay_i2_eq (const void *x, const void *y) -{ - return ((const struct delay_pair *) x)->i2 == y; + delay_htab.traverse (&max_uid); + delay_htab_i2.traverse (&max_uid); } /* This function can be called by a port just before it starts the final @@ -699,19 +718,15 @@ record_delay_slot_pair (rtx i1, rtx i2, int cycles, int stages) p->cycles = cycles; p->stages = stages; - if (!delay_htab) + if (!delay_htab.is_created ()) { - delay_htab = htab_create (10, delay_hash_i1, delay_i1_eq, NULL); - delay_htab_i2 = htab_create (10, delay_hash_i2, delay_i2_eq, free); + delay_htab.create (10); + delay_htab_i2.create (10); } - slot = ((struct delay_pair **) - htab_find_slot_with_hash (delay_htab, i1, htab_hash_pointer (i1), - INSERT)); + slot = delay_htab.find_slot_with_hash (i1, htab_hash_pointer (i1), INSERT); p->next_same_i1 = *slot; *slot = p; - slot = ((struct delay_pair **) - htab_find_slot_with_hash (delay_htab_i2, i2, htab_hash_pointer (i2), - INSERT)); + slot = delay_htab_i2.find_slot_with_hash (i2, htab_hash_pointer (i2), INSERT); *slot = p; } @@ -722,12 +737,10 @@ real_insn_for_shadow (rtx insn) { struct delay_pair *pair; - if (delay_htab == NULL) + if (!delay_htab.is_created ()) return NULL_RTX; - pair - = (struct delay_pair *)htab_find_with_hash (delay_htab_i2, insn, - htab_hash_pointer (insn)); + pair = delay_htab_i2.find_with_hash (insn, htab_hash_pointer (insn)); if (!pair || pair->stages > 0) return NULL_RTX; return pair->i1; @@ -755,12 +768,10 @@ add_delay_dependencies (rtx insn) sd_iterator_def sd_it; dep_t dep; - if (!delay_htab) + if (!delay_htab.is_created ()) return; - pair - = (struct delay_pair *)htab_find_with_hash (delay_htab_i2, insn, - htab_hash_pointer (insn)); + pair = delay_htab_i2.find_with_hash (insn, htab_hash_pointer (insn)); if (!pair) return; add_dependence (insn, pair->i1, REG_DEP_ANTI); @@ -771,8 +782,7 @@ add_delay_dependencies (rtx insn) { rtx pro = DEP_PRO (dep); struct delay_pair *other_pair - = (struct delay_pair *)htab_find_with_hash (delay_htab_i2, pro, - htab_hash_pointer (pro)); + = delay_htab_i2.find_with_hash (pro, htab_hash_pointer (pro)); if (!other_pair || other_pair->stages) continue; if (pair_delay (other_pair) >= pair_delay (pair)) @@ -1395,12 +1405,11 @@ dep_cost_1 (dep_t link, dw_t dw) if (DEP_COST (link) != UNKNOWN_DEP_COST) return DEP_COST (link); - if (delay_htab) + if (delay_htab.is_created ()) { struct delay_pair *delay_entry; delay_entry - = (struct delay_pair *)htab_find_with_hash (delay_htab_i2, used, - htab_hash_pointer (used)); + = delay_htab_i2.find_with_hash (used, htab_hash_pointer (used)); if (delay_entry) { if (delay_entry->i1 == insn) @@ -5726,12 +5735,12 @@ prune_ready_list (state_t temp_state, bool first_cycle_insn_p, { int delay_cost = 0; - if (delay_htab) + if (delay_htab.is_created ()) { struct delay_pair *delay_entry; delay_entry - = (struct delay_pair *)htab_find_with_hash (delay_htab, insn, - htab_hash_pointer (insn)); + = delay_htab.find_with_hash (insn, + htab_hash_pointer (insn)); while (delay_entry && delay_cost == 0) { delay_cost = estimate_shadow_tick (delay_entry); @@ -6189,14 +6198,13 @@ schedule_block (basic_block *target_bb, state_t init_state) goto restart_choose_ready; } - if (delay_htab) + if (delay_htab.is_created ()) { /* If this insn is the first part of a delay-slot pair, record a backtrack point. */ struct delay_pair *delay_entry; delay_entry - = (struct delay_pair *)htab_find_with_hash (delay_htab, insn, - htab_hash_pointer (insn)); + = delay_htab.find_with_hash (insn, htab_hash_pointer (insn)); if (delay_entry) { save_backtrack_point (delay_entry, ls); @@ -6761,10 +6769,10 @@ sched_finish (void) void free_delay_pairs (void) { - if (delay_htab) + if (delay_htab.is_created ()) { - htab_empty (delay_htab); - htab_empty (delay_htab_i2); + delay_htab.empty (); + delay_htab_i2.empty (); } } -- cgit v1.1