===================================================================
@@ -106,6 +106,7 @@ #define REG_OK_STRICT
#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
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 abi = call_insn_abi (p);
+ if (regno >= 0
+ && regno < FIRST_PSEUDO_REGISTER
+ && 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
+ && abi.clobbers_reg_p (mode, valueno))
+ return 0;
}
if (INSN_P (p))
===================================================================
@@ -42,6 +42,7 @@ Software Foundation; either version 3, o
#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 @@ #define spill_indirect_levels \
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 o
&& (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
+ &= ~call_insn_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 *cha
: 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 *cha
: 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 *cha
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);