From 12e20dde63c77eb696118e2624aacf8f11feb1f9 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Mon, 30 Sep 2019 16:21:23 +0000 Subject: [PATCH] Remove global call sets: reload.c The inheritance code in find_equiv_reg can use clobbers_reg_p to test whether a call clobbers either of the equivalent registers. reload and find_reg use crtl->abi to test whether a register needs to be saved in the prologue before use. reload_as_needed can use full_and_partial_reg_clobbers and thus avoid needing to keep its own record of which registers are part call-clobbered. 2019-09-30 Richard Sandiford gcc/ * reload.c: Include function-abi.h. (find_equiv_reg): Use clobbers_reg_p to test whether either of the equivalent registers is clobbered by a call. * reload1.c: Include function-abi.h. (reg_reloaded_call_part_clobbered): Delete. (reload): Use crtl->abi to test which registers would need saving in the prologue before use. (find_reg): Likewise. (emit_reload_insns): Remove code for reg_reloaded_call_part_clobbered. (reload_as_needed): Likewise. Use full_and_partial_reg_clobbers instead of call_used_or_fixed_regs | reg_reloaded_call_part_clobbered. From-SVN: r276333 --- gcc/ChangeLog | 14 ++++++++++++++ gcc/reload.c | 24 ++++++++++-------------- gcc/reload1.c | 38 ++++++-------------------------------- 3 files changed, 30 insertions(+), 46 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 6458d2b2e3b..3887c43f1ff 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,17 @@ +2019-09-30 Richard Sandiford + + * reload.c: Include function-abi.h. + (find_equiv_reg): Use clobbers_reg_p to test whether either + of the equivalent registers is clobbered by a call. + * reload1.c: Include function-abi.h. + (reg_reloaded_call_part_clobbered): Delete. + (reload): Use crtl->abi to test which registers would need + saving in the prologue before use. + (find_reg): Likewise. + (emit_reload_insns): Remove code for reg_reloaded_call_part_clobbered. + (reload_as_needed): Likewise. Use full_and_partial_reg_clobbers + instead of call_used_or_fixed_regs | reg_reloaded_call_part_clobbered. + 2019-09-30 Richard Sandiford * regrename.h (du_head::call_clobber_mask): New field. diff --git a/gcc/reload.c b/gcc/reload.c index b7601307f82..8582b4840ae 100644 --- a/gcc/reload.c +++ b/gcc/reload.c @@ -106,6 +106,7 @@ a register with any other reload. */ #include "reload.h" #include "addresses.h" #include "params.h" +#include "function-abi.h" /* True if X is a constant that can be forced into the constant pool. MODE is the mode of the operand, or VOIDmode if not known. */ @@ -6904,24 +6905,19 @@ find_equiv_reg (rtx goal, rtx_insn *insn, enum reg_class rclass, int other, if either of the two is in a call-clobbered register, or memory. */ if (CALL_P (p)) { - int i; - if (goal_mem || need_stable_sp) return 0; - if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER) - for (i = 0; i < nregs; ++i) - if (call_used_or_fixed_reg_p (regno + i) - || targetm.hard_regno_call_part_clobbered (0, regno + i, - mode)) - return 0; + function_abi callee_abi = insn_callee_abi (p); + if (regno >= 0 + && regno < FIRST_PSEUDO_REGISTER + && callee_abi.clobbers_reg_p (mode, regno)) + return 0; - if (valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER) - for (i = 0; i < valuenregs; ++i) - if (call_used_or_fixed_reg_p (valueno + i) - || targetm.hard_regno_call_part_clobbered (0, valueno + i, - mode)) - return 0; + if (valueno >= 0 + && valueno < FIRST_PSEUDO_REGISTER + && callee_abi.clobbers_reg_p (mode, valueno)) + return 0; } if (INSN_P (p)) diff --git a/gcc/reload1.c b/gcc/reload1.c index 39dff6a32b2..79a7ff6eb93 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -42,6 +42,7 @@ along with GCC; see the file COPYING3. If not see #include "except.h" #include "dumpfile.h" #include "rtl-iter.h" +#include "function-abi.h" /* This file contains the reload pass of the compiler, which is run after register allocation has been done. It checks that @@ -120,11 +121,6 @@ static HARD_REG_SET reg_reloaded_valid; This is only valid if reg_reloaded_contents is set and valid. */ static HARD_REG_SET reg_reloaded_dead; -/* Indicate whether the register's current value is one that is not - safe to retain across a call, even for registers that are normally - call-saved. This is only meaningful for members of reg_reloaded_valid. */ -static HARD_REG_SET reg_reloaded_call_part_clobbered; - /* Number of spill-regs so far; number of valid elements of spill_regs. */ static int n_spills; @@ -795,7 +791,7 @@ reload (rtx_insn *first, int global) if (crtl->saves_all_registers) for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (! call_used_or_fixed_reg_p (i) + if (! crtl->abi->clobbers_full_reg_p (i) && ! fixed_regs[i] && ! LOCAL_REGNO (i)) df_set_regs_ever_live (i, true); @@ -1908,8 +1904,8 @@ find_reg (class insn_chain *chain, int order) && (inv_reg_alloc_order[regno] < inv_reg_alloc_order[best_reg]) #else - && call_used_or_fixed_reg_p (regno) - && ! call_used_or_fixed_reg_p (best_reg) + && crtl->abi->clobbers_full_reg_p (regno) + && !crtl->abi->clobbers_full_reg_p (best_reg) #endif )) { @@ -4464,7 +4460,6 @@ reload_as_needed (int live_known) reg_last_reload_reg = XCNEWVEC (rtx, max_regno); INIT_REG_SET (®_has_output_reload); CLEAR_HARD_REG_SET (reg_reloaded_valid); - CLEAR_HARD_REG_SET (reg_reloaded_call_part_clobbered); set_initial_elim_offsets (); @@ -4786,8 +4781,8 @@ reload_as_needed (int live_known) be partially clobbered by the call. */ else if (CALL_P (insn)) { - reg_reloaded_valid &= ~(call_used_or_fixed_regs - | reg_reloaded_call_part_clobbered); + reg_reloaded_valid + &= ~insn_callee_abi (insn).full_and_partial_reg_clobbers (); /* If this is a call to a setjmp-type function, we must not reuse any reload reg contents across the call; that will @@ -8193,13 +8188,6 @@ emit_reload_insns (class insn_chain *chain) : out_regno + k); reg_reloaded_insn[regno + k] = insn; SET_HARD_REG_BIT (reg_reloaded_valid, regno + k); - if (targetm.hard_regno_call_part_clobbered (0, regno + k, - mode)) - SET_HARD_REG_BIT (reg_reloaded_call_part_clobbered, - regno + k); - else - CLEAR_HARD_REG_BIT (reg_reloaded_call_part_clobbered, - regno + k); } } } @@ -8273,13 +8261,6 @@ emit_reload_insns (class insn_chain *chain) : in_regno + k); reg_reloaded_insn[regno + k] = insn; SET_HARD_REG_BIT (reg_reloaded_valid, regno + k); - if (targetm.hard_regno_call_part_clobbered (0, regno + k, - mode)) - SET_HARD_REG_BIT (reg_reloaded_call_part_clobbered, - regno + k); - else - CLEAR_HARD_REG_BIT (reg_reloaded_call_part_clobbered, - regno + k); } } } @@ -8388,13 +8369,6 @@ emit_reload_insns (class insn_chain *chain) reg_reloaded_insn[src_regno + k] = store_insn; CLEAR_HARD_REG_BIT (reg_reloaded_dead, src_regno + k); SET_HARD_REG_BIT (reg_reloaded_valid, src_regno + k); - if (targetm.hard_regno_call_part_clobbered - (0, src_regno + k, mode)) - SET_HARD_REG_BIT (reg_reloaded_call_part_clobbered, - src_regno + k); - else - CLEAR_HARD_REG_BIT (reg_reloaded_call_part_clobbered, - src_regno + k); SET_HARD_REG_BIT (reg_is_output_reload, src_regno + k); if (note) SET_HARD_REG_BIT (reg_reloaded_died, src_regno); -- 2.30.2