From d7bfd90745988e02a5358371e57a4b8b20ba9ff9 Mon Sep 17 00:00:00 2001 From: Maxim Kuvyrkov Date: Fri, 6 Oct 2006 21:49:07 +0000 Subject: [PATCH] sched-int.h (IS_SPECULATION_CHECK_P, [...]): New macros. 2006-10-06 Maxim Kuvyrkov * sched-int.h (IS_SPECULATION_CHECK_P, IS_SPECULATION_SIMPLE_CHECK_P): New macros. * sched-ebb.c (begin_schedule_ready): Use them. * haifa-sched.c (schedule_insn, move_insn, try_ready, add_to_speculative_block, create_check_block_twin, speculate_insn, fix_jump_move, move_block_after_check): Ditto. * sched-rgn.c (new_ready): Ditto. From-SVN: r117516 --- gcc/ChangeLog | 10 ++++++++++ gcc/haifa-sched.c | 31 ++++++++++++++----------------- gcc/sched-ebb.c | 2 +- gcc/sched-int.h | 8 ++++++++ gcc/sched-rgn.c | 2 +- 5 files changed, 34 insertions(+), 19 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 17dc8cae1cb8..e23ff15245fb 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,13 @@ +2006-10-06 Maxim Kuvyrkov + + * sched-int.h (IS_SPECULATION_CHECK_P, IS_SPECULATION_SIMPLE_CHECK_P): + New macros. + * sched-ebb.c (begin_schedule_ready): Use them. + * haifa-sched.c (schedule_insn, move_insn, try_ready, + add_to_speculative_block, create_check_block_twin, speculate_insn, + fix_jump_move, move_block_after_check): Ditto. + * sched-rgn.c (new_ready): Ditto. + 2006-10-06 Maxim Kuvyrkov PR rtl-optimization/29128 diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c index 78adee5723ab..ebe7f24ebb53 100644 --- a/gcc/haifa-sched.c +++ b/gcc/haifa-sched.c @@ -1190,8 +1190,7 @@ schedule_insn (rtx insn) resolve_dep (next, insn); - if (!RECOVERY_BLOCK (insn) - || RECOVERY_BLOCK (insn) == EXIT_BLOCK_PTR) + if (!IS_SPECULATION_BRANCHY_CHECK_P (insn)) { int effective_cost; @@ -1960,8 +1959,7 @@ move_insn (rtx insn) gcc_assert (!jump_p || ((current_sched_info->flags & SCHED_RGN) - && RECOVERY_BLOCK (insn) - && RECOVERY_BLOCK (insn) != EXIT_BLOCK_PTR) + && IS_SPECULATION_BRANCHY_CHECK_P (insn)) || (current_sched_info->flags & SCHED_EBB)); gcc_assert (BLOCK_FOR_INSN (PREV_INSN (insn)) == bb); @@ -3115,8 +3113,7 @@ try_ready (rtx next) or we simply don't care (*ts & HARD_DEP). */ gcc_assert (!ORIG_PAT (next) - || !RECOVERY_BLOCK (next) - || RECOVERY_BLOCK (next) == EXIT_BLOCK_PTR); + || !IS_SPECULATION_BRANCHY_CHECK_P (next)); if (*ts & HARD_DEP) { @@ -3128,11 +3125,11 @@ try_ready (rtx next) change_queue_index (next, QUEUE_NOWHERE); return -1; } - else if (!(*ts & BEGIN_SPEC) && ORIG_PAT (next) && !RECOVERY_BLOCK (next)) + else if (!(*ts & BEGIN_SPEC) && ORIG_PAT (next) && !IS_SPECULATION_CHECK_P (next)) /* We should change pattern of every previously speculative instruction - and we determine if NEXT was speculative by using - ORIG_PAT field. Except one case - simple checks have ORIG_PAT - pat too, hence we also check for the RECOVERY_BLOCK. */ + ORIG_PAT field. Except one case - speculation checks have ORIG_PAT + pat too, so skip them. */ { change_pattern (next, ORIG_PAT (next)); ORIG_PAT (next) = 0; @@ -3444,7 +3441,7 @@ add_to_speculative_block (rtx insn) check = XEXP (link, 0); - if (RECOVERY_BLOCK (check)) + if (IS_SPECULATION_SIMPLE_CHECK_P (check)) { create_check_block_twin (check, true); link = LOG_LINKS (insn); @@ -3466,7 +3463,8 @@ add_to_speculative_block (rtx insn) && (DEP_STATUS (link) & DEP_TYPES) == DEP_TRUE); check = XEXP (link, 0); - gcc_assert (!RECOVERY_BLOCK (check) && !ORIG_PAT (check) + + gcc_assert (!IS_SPECULATION_CHECK_P (check) && !ORIG_PAT (check) && QUEUE_INDEX (check) == QUEUE_NOWHERE); rec = BLOCK_FOR_INSN (check); @@ -3718,7 +3716,7 @@ create_check_block_twin (rtx insn, bool mutate_p) gcc_assert (ORIG_PAT (insn) && (!mutate_p - || (RECOVERY_BLOCK (insn) == EXIT_BLOCK_PTR + || (IS_SPECULATION_SIMPLE_CHECK_P (insn) && !(TODO_SPEC (insn) & SPECULATIVE)))); /* Create recovery block. */ @@ -4091,7 +4089,7 @@ speculate_insn (rtx insn, ds_t request, rtx *new_pat) || (request & spec_info->mask) != request) return -1; - gcc_assert (!RECOVERY_BLOCK (insn)); + gcc_assert (!IS_SPECULATION_CHECK_P (insn)); if (request & BE_IN_SPEC) { @@ -4299,8 +4297,7 @@ fix_jump_move (rtx jump) jump_bb_next = jump_bb->next_bb; gcc_assert (current_sched_info->flags & SCHED_EBB - || (RECOVERY_BLOCK (jump) - && RECOVERY_BLOCK (jump) != EXIT_BLOCK_PTR)); + || IS_SPECULATION_BRANCHY_CHECK_P (jump)); if (!NOTE_INSN_BASIC_BLOCK_P (BB_END (jump_bb_next))) /* if jump_bb_next is not empty. */ @@ -4333,8 +4330,8 @@ move_block_after_check (rtx jump) update_bb_for_insn (jump_bb); - gcc_assert (RECOVERY_BLOCK (jump) - || RECOVERY_BLOCK (BB_END (jump_bb_next))); + gcc_assert (IS_SPECULATION_CHECK_P (jump) + || IS_SPECULATION_CHECK_P (BB_END (jump_bb_next))); unlink_block (jump_bb_next); link_block (jump_bb_next, bb); diff --git a/gcc/sched-ebb.c b/gcc/sched-ebb.c index 599241a47c84..b2e82b591824 100644 --- a/gcc/sched-ebb.c +++ b/gcc/sched-ebb.c @@ -145,7 +145,7 @@ begin_schedule_ready (rtx insn, rtx last) gcc_assert (!e || !(e->flags & EDGE_COMPLEX)); gcc_assert (BLOCK_FOR_INSN (insn) == last_bb - && !RECOVERY_BLOCK (insn) + && !IS_SPECULATION_CHECK_P (insn) && BB_HEAD (last_bb) != insn && BB_END (last_bb) == insn); diff --git a/gcc/sched-int.h b/gcc/sched-int.h index 3865013b9df0..ab9147803646 100644 --- a/gcc/sched-int.h +++ b/gcc/sched-int.h @@ -359,6 +359,14 @@ extern regset *glat_start, *glat_end; #define RECOVERY_BLOCK(INSN) (h_i_d[INSN_UID (INSN)].recovery_block) #define ORIG_PAT(INSN) (h_i_d[INSN_UID (INSN)].orig_pat) +/* INSN is either a simple or a branchy speculation check. */ +#define IS_SPECULATION_CHECK_P(INSN) (RECOVERY_BLOCK (INSN) != NULL) + +/* INSN is a speculation check that will simply reexecute the speculatively + scheduled instruction if the speculation fail. */ +#define IS_SPECULATION_SIMPLE_CHECK_P(INSN) \ + (RECOVERY_BLOCK (INSN) == EXIT_BLOCK_PTR) + /* INSN is a speculation check that will branch to RECOVERY_BLOCK if the speculation fail. Insns in that block will reexecute the speculatively scheduled code and then will return immediatelly after INSN thus preserving diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c index 612623a14b85..4c9c0dec2c26 100644 --- a/gcc/sched-rgn.c +++ b/gcc/sched-rgn.c @@ -2089,7 +2089,7 @@ new_ready (rtx next, ds_t ts) && ((recog_memoized (next) >= 0 && min_insn_conflict_delay (curr_state, next, next) > PARAM_VALUE (PARAM_MAX_SCHED_INSN_CONFLICT_DELAY)) - || RECOVERY_BLOCK (next) + || IS_SPECULATION_CHECK_P (next) || !check_live (next, INSN_BB (next)) || (not_ex_free = !is_exception_free (next, INSN_BB (next), target_bb)))))