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  <richard.sandiford@arm.com>

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6458d2b2e3bfcadf94fdef4afdac9bb649835f59..3887c43f1ffac623ca76dbf2f06c2d6fd81b816f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2019-09-30  Richard Sandiford  <richard.sandiford@arm.com>
+
+       * 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  <richard.sandiford@arm.com>
 
        * regrename.h (du_head::call_clobber_mask): New field.

diff --git a/gcc/reload.c b/gcc/reload.c
index b7601307f82f60dca6165dfc3c2294e660b17d3d..8582b4840ae03ad3889696772523def3d4c469da 100644 (file)
--- 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 39dff6a32b2dc805bcd1f8e7055b56c999e0064a..79a7ff6eb93d87635aa217dfc04a0a130d57a3b3 100644 (file)
--- 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 (&reg_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);