From e2f6ff946a121528203fcbde68fdd58942f9a57b Mon Sep 17 00:00:00 2001 From: Maxim Kuvyrkov Date: Tue, 14 Aug 2007 06:40:34 +0000 Subject: sched-int.h (struct _dep): Rename field 'kind' to 'type'. * sched-int.h (struct _dep): Rename field 'kind' to 'type'. (DEP_KIND): Rename to DEP_TYPE. Update all uses. (dep_def): New typedef. (init_dep_1, sd_debug_dep): Declare functions. (DEP_LINK_KIND): Rename to DEP_LINK_TYPE. (debug_dep_links): Remove. (struct _deps_list): New field 'n_links'. (DEPS_LIST_N_LINKS): New macro. (FOR_EACH_DEP_LINK): Remove. (create_deps_list, free_deps_list, delete_deps_list): Remove declaration. (deps_list_empty_p, debug_deps_list, add_back_dep_to_deps_list): Ditto. (find_link_by_pro_in_deps_list, find_link_by_con_in_deps_list): Ditto. (copy_deps_list_change_con, move_dep_link): Ditto. (struct haifa_insn_data): Split field 'back_deps' into 'hard_back_deps' and 'spec_back_deps'. New field 'resolved_forw_deps'. Remove field 'dep_count'. (INSN_BACK_DEPS): Remove. (INSN_HARD_BACK_DEPS, INSN_SPEC_BACK_DEPS, INSN_RESOLVED_FORW_DEPS): New macros. (INSN_DEP_COUNT): Remove. (enum DEPS_ADJUST_RESULT): Add new constant DEP_NODEP. Fix comments. (spec_info, haifa_recovery_block_was_added_during_scheduling_p): Declare global variables. (deps_pools_are_empty_p, sched_free_deps): Declare functions. (add_forw_dep, compute_forward_dependences): Remove declarations. (add_or_update_back_dep, add_or_update_back_forw_dep): Ditto. (add_back_forw_dep, delete_back_forw_dep): Ditto. (debug_ds, sched_insn_is_legitimate_for_speculation_p): Declare functions. (SD_LIST_NONE, SD_LIST_HARD_BACK, SD_LIST_SPEC_BACK, SD_LIST_FORW): New constants. (SD_LIST_RES_BACK, SD_LIST_RES_FORW, SD_LIST_BACK): Ditto. (sd_list_types_def): New typedef. (sd_next_list): Declare function. (struct _sd_iterator): New type. (sd_iterator_def): New typedef. (sd_iterator_start, sd_iterator_cond, sd_iterator_next): New inline functions. (FOR_EACH_DEP): New cycle wrapper. (sd_lists_size, sd_lists_empty_p, sd_init_insn, sd_finish_insn): Declare functions. (sd_find_dep_between, sd_add_dep, sd_add_or_update_dep): Ditto. (sd_resolve_dep, sd_copy_back_deps, sd_delete_dep, sd_debug_lists): Ditto. * sched-deps.c (init_dep_1): Make global. (DUMP_DEP_PRO, DUMP_DEP_CON, DUMP_DEP_STATUS, DUMP_DEP_ALL): New constants. (dump_dep): New static function. (dump_dep_flags): New static variable. (sd_debug_dep): New function. (add_to_deps_list, remove_from_deps_list): Update 'n_links' field of the list. (move_dep_link): Use remove_from_deps_list (), instead of detach_dep_link (). (dep_links_consistent_p, dump_dep_links, debug_dep_links): Remove. (dep_link_is_detached_p): New static function. (deps_obstack, dl_obstack, dn_obstack): Remove. Use dn_pool, dl_pool instead. (dn_pool, dl_pool): New alloc_pools. (dn_pool_diff, dl_pool_diff): New static variables. (create_dep_node, delete_dep_node): New static function. (create_deps_list): Make it static. Use alloc_pool 'dl_pool'. (deps_list_empty_p): Make it static. Use 'n_links' field. (deps_pools_are_empty_p): New static function. (alloc_deps_list, delete_deps_list): Remove. (dump_deps_list, debug_deps_list, add_back_dep_to_deps_list): Remove. (find_link_by_pro_in_deps_list, find_link_by_con_in_deps_list): Ditto. (copy_deps_list_change_con): Remove. Use sd_copy_back_deps () instead. (forward_dependency_cache): Remove. (maybe_add_or_update_back_dep_1, add_or_update_back_dep_1): Remove 'back' from the names. Change signature to use dep_t instead of equivalent quad. (add_back_dep): Ditto. Make global. (check_dep_status): Rename to check_dep (). (sd_next_list, sd_lists_size, sd_lists_empty_p, sd_init_insn): New functions. (sd_finish_insn): Ditto. (sd_find_dep_between_no_cache): New static function. (sd_find_dep_between): New function. (ask_dependency_caches, set_dependency_caches): New static functions. (update_dependency_caches, change_spec_dep_to_hard, update_dep): Ditto. (add_or_update_dep_1): Separate pieces of functionality into ask_dependency_caches (), update_dependency_caches (), change_spec_dep_to_hard (), update_dep (). (get_back_and_forw_lists): New static function. (sd_add_dep): Separate setting of dependency caches into set_dependency_caches (). (sd_add_or_update_dep, sd_resolve_dep, sd_copy_back_deps): New functions. (sd_delete_dep): Ditto. (DUMP_LISTS_SIZE, DUMP_LISTS_DEPS, DUMP_LISTS_ALL): New constants. (dump_lists): New static function. (sd_debug_lists): New debug function. (delete_all_dependences, fixup_sched_groups): Update to use sd_* infrastructure. (sched_analyze_2): Create data-speculative dependency only if data-speculation is enabled. (sched_analyze_insn): If insn cannot be speculative, make all its dependencies non-speculative. (sched_analyze): Use sd_init_insn (). (add_forw_dep, compute_forward_dependencies): Remove. (delete_dep_nodes_in_back_deps): New static function. (sched_free_deps): New function. (init_dependency_caches): Init alloc_pools. (extend_depedency_caches): Update after removing of forward_dependency_cache. (free_dependency_caches): Ditto. Free alloc_pools. (adjust_add_sorted_back_dep, adjust_back_add_forw_dep): Remove. (delete_forw_dep, add_or_update_back_dep, add_or_update_back_forw_dep): Ditto. (add_back_forw_dep, delete_back_forw_dep): Ditto. (add_dependence): Use init_dep (). (get_dep_weak_1): New static function. (get_dep_weak): Move logic to get_dep_weak_1 (). (dump_ds): New static function moved from haifa-sched.c: debug_spec_status (). (debug_ds): New debug function. (check_dep_status): Rename to check_dep (). Update to check whole dependencies. * haifa-sched.c (spec_info): Make global. (added_recovery_block_p): Rename to 'haifa_recovery_block_was_added_during_current_schedule_block_p'. (haifa_recovery_block_was_added_during_scheduling_p): New variable. (dep_cost, priority, rank_for_schedule, schedule_insn): Update to use new interfaces. (ok_for_early_queue_removal): Ditto. (schedule_block): Initialize logical uids of insns emitted by the target. (sched_init): Initialize new variable. (fix_inter_tick, try_ready, fix_tick_ready): Update to use new interfaces. (extend_global): Initialize insn data. (init_h_i_d): Remove code that is now handled in sd_init_insn (). (process_insn_forw_deps_be_in_spec): Change signature. Update to use new interfaces. (add_to_speculative_block): Update to use new interfaces. (create_recovery_block): Set new variables. (create_check_block_twin, fix_recovery_deps): Update to use new interfaces. (sched_insn_is_legitimate_for_speculation_p): New function. (speculate_insn): Move checking logic to sched_insn_is_legitimate_for_speculation_p (). (sched_remove_insn): Finalize sched-deps information of instruction. (clear_priorities, add_jump_dependencies): Update to use new interfaces. (debug_spec_status): Rename to dump_ds () and move to sched-deps.c. * sched-rgn.c (set_spec_fed, find_conditional_protection): Update to use new interfaces. (is_conditionally_protected, is_pfree, is_prisky) Ditto. (new_ready): Try to use control speculation only if it is available. (add_branch_dependences): Update to use new interfaces. (compute_block_backward_dependences): Rename to compute_block_dependences (). Call targetm.sched.dependencies_evaluation_hook (). (free_block_dependencies): New static function. (debug_dependencies): Update to use new interfaces. (schedule_region): Remove separate computation of forward dependencies. Move call of targetm.sched.dependencies_evaluation_hook () to compute_block_dependences (). Free dependencies at the end of scheduling the region. * sched-ebb.c (earliest_block_with_similiar_load): Update to use new interfaces. (add_deps_for_risky_insns): Ditto. (schedule_ebb): Remove separate computation of forward dependencies. Free dependencies at the end of scheduling the ebb. * ddg.c (create_ddg_dependence): Update to use new interfaces. (build_intra_loop_deps): Ditto. Remove separate computation of forward dependencies. Free sched-deps dependencies. * config/ia64/ia64.c (ia64_dependencies_evaluation_hook): Update to use new interfaces. (ia64_dfa_new_cycle, ia64_gen_check): Ditto. * config/rs6000/rs6000.c (rs6000_is_costly_dependence): Update to use new interfaces. (is_costly_group): Ditto. From-SVN: r127405 --- gcc/sched-rgn.c | 119 ++++++++++++++++++++++++++++++++------------------------ 1 file changed, 68 insertions(+), 51 deletions(-) (limited to 'gcc/sched-rgn.c') diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c index 97aea50..760420b 100644 --- a/gcc/sched-rgn.c +++ b/gcc/sched-rgn.c @@ -277,7 +277,7 @@ static int is_exception_free (rtx, int, int); static bool sets_likely_spilled (rtx); static void sets_likely_spilled_1 (rtx, const_rtx, void *); static void add_branch_dependences (rtx, rtx); -static void compute_block_backward_dependences (int); +static void compute_block_dependences (int); static void init_regions (void); static void schedule_region (int); @@ -1697,11 +1697,12 @@ update_live (rtx insn, int src) static void set_spec_fed (rtx load_insn) { - dep_link_t link; + sd_iterator_def sd_it; + dep_t dep; - FOR_EACH_DEP_LINK (link, INSN_FORW_DEPS (load_insn)) - if (DEP_LINK_KIND (link) == REG_DEP_TRUE) - FED_BY_SPEC_LOAD (DEP_LINK_CON (link)) = 1; + FOR_EACH_DEP (load_insn, SD_LIST_FORW, sd_it, dep) + if (DEP_TYPE (dep) == REG_DEP_TRUE) + FED_BY_SPEC_LOAD (DEP_CON (dep)) = 1; } /* On the path from the insn to load_insn_bb, find a conditional @@ -1710,18 +1711,19 @@ branch depending on insn, that guards the speculative load. */ static int find_conditional_protection (rtx insn, int load_insn_bb) { - dep_link_t link; + sd_iterator_def sd_it; + dep_t dep; /* Iterate through DEF-USE forward dependences. */ - FOR_EACH_DEP_LINK (link, INSN_FORW_DEPS (insn)) + FOR_EACH_DEP (insn, SD_LIST_FORW, sd_it, dep) { - rtx next = DEP_LINK_CON (link); + rtx next = DEP_CON (dep); if ((CONTAINING_RGN (BLOCK_NUM (next)) == CONTAINING_RGN (BB_TO_BLOCK (load_insn_bb))) && IS_REACHABLE (INSN_BB (next), load_insn_bb) && load_insn_bb != INSN_BB (next) - && DEP_LINK_KIND (link) == REG_DEP_TRUE + && DEP_TYPE (dep) == REG_DEP_TRUE && (JUMP_P (next) || find_conditional_protection (next, load_insn_bb))) return 1; @@ -1746,14 +1748,15 @@ find_conditional_protection (rtx insn, int load_insn_bb) static int is_conditionally_protected (rtx load_insn, int bb_src, int bb_trg) { - dep_link_t link; + sd_iterator_def sd_it; + dep_t dep; - FOR_EACH_DEP_LINK (link, INSN_BACK_DEPS (load_insn)) + FOR_EACH_DEP (load_insn, SD_LIST_BACK, sd_it, dep) { - rtx insn1 = DEP_LINK_PRO (link); + rtx insn1 = DEP_PRO (dep); /* Must be a DEF-USE dependence upon non-branch. */ - if (DEP_LINK_KIND (link) != REG_DEP_TRUE + if (DEP_TYPE (dep) != REG_DEP_TRUE || JUMP_P (insn1)) continue; @@ -1796,27 +1799,29 @@ is_conditionally_protected (rtx load_insn, int bb_src, int bb_trg) static int is_pfree (rtx load_insn, int bb_src, int bb_trg) { - dep_link_t back_link; + sd_iterator_def back_sd_it; + dep_t back_dep; candidate *candp = candidate_table + bb_src; if (candp->split_bbs.nr_members != 1) /* Must have exactly one escape block. */ return 0; - FOR_EACH_DEP_LINK (back_link, INSN_BACK_DEPS (load_insn)) + FOR_EACH_DEP (load_insn, SD_LIST_BACK, back_sd_it, back_dep) { - rtx insn1 = DEP_LINK_PRO (back_link); + rtx insn1 = DEP_PRO (back_dep); - if (DEP_LINK_KIND (back_link) == REG_DEP_TRUE) + if (DEP_TYPE (back_dep) == REG_DEP_TRUE) + /* Found a DEF-USE dependence (insn1, load_insn). */ { - /* Found a DEF-USE dependence (insn1, load_insn). */ - dep_link_t fore_link; + sd_iterator_def fore_sd_it; + dep_t fore_dep; - FOR_EACH_DEP_LINK (fore_link, INSN_FORW_DEPS (insn1)) + FOR_EACH_DEP (insn1, SD_LIST_FORW, fore_sd_it, fore_dep) { - rtx insn2 = DEP_LINK_CON (fore_link); + rtx insn2 = DEP_CON (fore_dep); - if (DEP_LINK_KIND (fore_link) == REG_DEP_TRUE) + if (DEP_TYPE (fore_dep) == REG_DEP_TRUE) { /* Found a DEF-USE dependence (insn1, insn2). */ if (haifa_classify_insn (insn2) != PFREE_CANDIDATE) @@ -1849,7 +1854,7 @@ is_prisky (rtx load_insn, int bb_src, int bb_trg) if (FED_BY_SPEC_LOAD (load_insn)) return 1; - if (deps_list_empty_p (INSN_BACK_DEPS (load_insn))) + if (sd_lists_empty_p (load_insn, SD_LIST_BACK)) /* Dependence may 'hide' out of the region. */ return 1; @@ -2081,7 +2086,8 @@ new_ready (rtx next, ds_t ts) if (not_ex_free /* We are here because is_exception_free () == false. But we possibly can handle that with control speculation. */ - && current_sched_info->flags & DO_SPECULATION) + && (current_sched_info->flags & DO_SPECULATION) + && (spec_info->mask & BEGIN_CONTROL)) /* Here we got new control-speculative instruction. */ ts = set_dep_weak (ts, BEGIN_CONTROL, MAX_DEP_WEAK); else @@ -2263,8 +2269,7 @@ add_branch_dependences (rtx head, rtx tail) if (!NOTE_P (insn)) { if (last != 0 - && (find_link_by_pro_in_deps_list (INSN_BACK_DEPS (last), insn) - == NULL)) + && sd_find_dep_between (insn, last, false) == NULL) { if (! sched_insns_conditions_mutex_p (last, insn)) add_dependence (last, insn, REG_DEP_ANTI); @@ -2472,7 +2477,7 @@ propagate_deps (int bb, struct deps *pred_deps) pred_deps->pending_write_mems = 0; } -/* Compute backward dependences inside bb. In a multiple blocks region: +/* Compute dependences inside bb. In a multiple blocks region: (1) a bb is analyzed after its predecessors, and (2) the lists in effect at the end of bb (after analyzing for bb) are inherited by bb's successors. @@ -2490,7 +2495,7 @@ propagate_deps (int bb, struct deps *pred_deps) similar, and the result is interblock dependences in the region. */ static void -compute_block_backward_dependences (int bb) +compute_block_dependences (int bb) { rtx head, tail; struct deps tmp_deps; @@ -2500,6 +2505,7 @@ compute_block_backward_dependences (int bb) /* Do the analysis for this block. */ gcc_assert (EBB_FIRST_BB (bb) == EBB_LAST_BB (bb)); get_ebb_head_tail (EBB_FIRST_BB (bb), EBB_LAST_BB (bb), &head, &tail); + sched_analyze (&tmp_deps, head, tail); add_branch_dependences (head, tail); @@ -2508,6 +2514,21 @@ compute_block_backward_dependences (int bb) /* Free up the INSN_LISTs. */ free_deps (&tmp_deps); + + if (targetm.sched.dependencies_evaluation_hook) + targetm.sched.dependencies_evaluation_hook (head, tail); +} + +/* Free dependencies of instructions inside BB. */ +static void +free_block_dependencies (int bb) +{ + rtx head; + rtx tail; + + get_ebb_head_tail (EBB_FIRST_BB (bb), EBB_LAST_BB (bb), &head, &tail); + + sched_free_deps (head, tail, true); } /* Remove all INSN_LISTs and EXPR_LISTs from the pending lists and add @@ -2527,7 +2548,8 @@ free_pending_lists (void) } } - +/* Print dependences for debugging starting from FROM_BB. + Callable from debugger. */ /* Print dependences for debugging starting from FROM_BB. Callable from debugger. */ void @@ -2567,8 +2589,6 @@ void debug_dependencies (rtx head, rtx tail) for (insn = head; insn != next_tail; insn = NEXT_INSN (insn)) { - dep_link_t link; - if (! INSN_P (insn)) { int n; @@ -2589,7 +2609,7 @@ void debug_dependencies (rtx head, rtx tail) INSN_UID (insn), INSN_CODE (insn), BLOCK_NUM (insn), - INSN_DEP_COUNT (insn), + sd_lists_size (insn, SD_LIST_BACK), INSN_PRIORITY (insn), insn_cost (insn)); @@ -2599,8 +2619,13 @@ void debug_dependencies (rtx head, rtx tail) print_reservation (sched_dump, insn); fprintf (sched_dump, "\t: "); - FOR_EACH_DEP_LINK (link, INSN_FORW_DEPS (insn)) - fprintf (sched_dump, "%d ", INSN_UID (DEP_LINK_CON (link))); + { + sd_iterator_def sd_it; + dep_t dep; + + FOR_EACH_DEP (insn, SD_LIST_FORW, sd_it, dep) + fprintf (sched_dump, "%d ", INSN_UID (DEP_CON (dep))); + } fprintf (sched_dump, "\n"); } @@ -2658,23 +2683,9 @@ schedule_region (int rgn) for (bb = 0; bb < current_nr_blocks; bb++) init_deps (bb_deps + bb); - /* Compute backward dependencies. */ + /* Compute dependencies. */ for (bb = 0; bb < current_nr_blocks; bb++) - compute_block_backward_dependences (bb); - - /* Compute forward dependencies. */ - for (bb = current_nr_blocks - 1; bb >= 0; bb--) - { - rtx head, tail; - - gcc_assert (EBB_FIRST_BB (bb) == EBB_LAST_BB (bb)); - get_ebb_head_tail (EBB_FIRST_BB (bb), EBB_LAST_BB (bb), &head, &tail); - - compute_forward_dependences (head, tail); - - if (targetm.sched.dependencies_evaluation_hook) - targetm.sched.dependencies_evaluation_hook (head, tail); - } + compute_block_dependences (bb); free_pending_lists (); @@ -2826,7 +2837,6 @@ schedule_region (int rgn) /* Sanity check: verify that all region insns were scheduled. */ gcc_assert (sched_rgn_n_insns == rgn_n_insns); - /* Done with this region. */ if (current_nr_blocks > 1) @@ -2837,6 +2847,13 @@ schedule_region (int rgn) sbitmap_vector_free (ancestor_edges); free (rgn_edges); } + + /* Free dependencies. */ + for (bb = 0; bb < current_nr_blocks; ++bb) + free_block_dependencies (bb); + + gcc_assert (haifa_recovery_bb_ever_added_p + || deps_pools_are_empty_p ()); } /* Initialize data structures for region scheduling. */ -- cgit v1.1