Update copyright years.

[thirdparty/gcc.git] / gcc / caller-save.c

diff --git a/gcc/caller-save.c b/gcc/caller-save.c
index b6bcb7bd75f5e9c5a2253a5011d61db6ab96f41b..6f22d718e171324aea326848932528e8d1e1678f 100644 (file)
--- a/gcc/caller-save.c
+++ b/gcc/caller-save.c
@@ -1,5 +1,5 @@
 /* Save and restore call-clobbered registers which are live across a call.
-   Copyright (C) 1989-2019 Free Software Foundation, Inc.
+   Copyright (C) 1989-2020 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -37,6 +37,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "dumpfile.h"
 #include "rtl-iter.h"
 #include "target.h"
+#include "function-abi.h"
 
 #define MOVE_MAX_WORDS (MOVE_MAX / UNITS_PER_WORD)
 
@@ -192,29 +193,17 @@ init_caller_save (void)
 
   caller_save_initialized_p = true;
 
-  CLEAR_HARD_REG_SET (no_caller_save_reg_set);
   /* First find all the registers that we need to deal with and all
      the modes that they can have.  If we can't find a mode to use,
      we can't have the register live over calls.  */
 
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
-    {
-      if (call_used_regs[i]
-          && !TEST_HARD_REG_BIT (call_fixed_reg_set, i))
-       {
-         for (j = 1; j <= MOVE_MAX_WORDS; j++)
-           {
-             regno_save_mode[i][j] = HARD_REGNO_CALLER_SAVE_MODE (i, j,
-                                                                  VOIDmode);
-             if (regno_save_mode[i][j] == VOIDmode && j == 1)
-               {
-                 SET_HARD_REG_BIT (call_fixed_reg_set, i);
-               }
-           }
-       }
-      else
-       regno_save_mode[i][1] = VOIDmode;
-    }
+    for (j = 1; j <= MOVE_MAX_WORDS; j++)
+      {
+       regno_save_mode[i][j] = HARD_REGNO_CALLER_SAVE_MODE (i, j, VOIDmode);
+       if (regno_save_mode[i][j] == VOIDmode && j == 1)
+         CLEAR_HARD_REG_BIT (savable_regs, i);
+      }
 
   /* The following code tries to approximate the conditions under which
      we can easily save and restore a register without scratch registers or
@@ -275,11 +264,7 @@ init_caller_save (void)
        {
          regno_save_mode[i][j] = VOIDmode;
          if (j == 1)
-           {
-             SET_HARD_REG_BIT (call_fixed_reg_set, i);
-             if (call_used_regs[i])
-               SET_HARD_REG_BIT (no_caller_save_reg_set, i);
-           }
+           CLEAR_HARD_REG_BIT (savable_regs, i);
        }
 }
 
@@ -442,7 +427,7 @@ setup_save_areas (void)
       freq = REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn));
       REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
                               &chain->live_throughout);
-      get_call_reg_set_usage (insn, &used_regs, call_used_reg_set);
+      used_regs = insn_callee_abi (insn).full_reg_clobbers ();
 
       /* Record all registers set in this call insn.  These don't
         need to be saved.  N.B. the call insn might set a subreg
@@ -455,9 +440,8 @@ setup_save_areas (void)
       if (SIBLING_CALL_P (insn) && crtl->return_rtx)
        mark_set_regs (crtl->return_rtx, NULL_RTX, &this_insn_sets);
 
-      AND_COMPL_HARD_REG_SET (used_regs, call_fixed_reg_set);
-      AND_COMPL_HARD_REG_SET (used_regs, this_insn_sets);
-      hard_regs_to_save &= used_regs;
+      used_regs &= ~(fixed_reg_set | this_insn_sets);
+      hard_regs_to_save &= used_regs & savable_regs;
       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
        if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
          {
@@ -526,7 +510,7 @@ setup_save_areas (void)
 
          REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
                                   &chain->live_throughout);
-         get_call_reg_set_usage (insn, &used_regs, call_used_reg_set);
+         used_regs = insn_callee_abi (insn).full_reg_clobbers ();
 
          /* Record all registers set in this call insn.  These don't
             need to be saved.  N.B. the call insn might set a subreg
@@ -540,9 +524,8 @@ setup_save_areas (void)
          if (SIBLING_CALL_P (insn) && crtl->return_rtx)
            mark_set_regs (crtl->return_rtx, NULL_RTX, &this_insn_sets);
 
-         AND_COMPL_HARD_REG_SET (used_regs, call_fixed_reg_set);
-         AND_COMPL_HARD_REG_SET (used_regs, this_insn_sets);
-         hard_regs_to_save &= used_regs;
+         used_regs &= ~(fixed_reg_set | this_insn_sets);
+         hard_regs_to_save &= used_regs & savable_regs;
          for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
            if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
              {
@@ -796,7 +779,7 @@ save_call_clobbered_regs (void)
                 afterwards.  */
              CLEAR_HARD_REG_SET (this_insn_sets);
              note_stores (insn, mark_set_regs, &this_insn_sets);
-             AND_COMPL_HARD_REG_SET (hard_regs_saved, this_insn_sets);
+             hard_regs_saved &= ~this_insn_sets;
            }
 
          if (code == CALL_INSN
@@ -805,7 +788,6 @@ save_call_clobbered_regs (void)
            {
              unsigned regno;
              HARD_REG_SET hard_regs_to_save;
-             HARD_REG_SET call_def_reg_set;
              reg_set_iterator rsi;
              rtx cheap;
 
@@ -852,12 +834,12 @@ save_call_clobbered_regs (void)
              note_stores (insn, mark_set_regs, &this_insn_sets);
 
              /* Compute which hard regs must be saved before this call.  */
-             AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
-             AND_COMPL_HARD_REG_SET (hard_regs_to_save, this_insn_sets);
-             AND_COMPL_HARD_REG_SET (hard_regs_to_save, hard_regs_saved);
-             get_call_reg_set_usage (insn, &call_def_reg_set,
-                                     call_used_reg_set);
-             hard_regs_to_save &= call_def_reg_set;
+             function_abi callee_abi = insn_callee_abi (insn);
+             hard_regs_to_save &= ~(fixed_reg_set
+                                    | this_insn_sets
+                                    | hard_regs_saved);
+             hard_regs_to_save &= savable_regs;
+             hard_regs_to_save &= callee_abi.full_reg_clobbers ();
 
              for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
                if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
@@ -872,7 +854,8 @@ save_call_clobbered_regs (void)
              
              if (cheap
                  && HARD_REGISTER_P (cheap)
-                 && TEST_HARD_REG_BIT (call_used_reg_set, REGNO (cheap)))
+                 && callee_abi.clobbers_reg_p (GET_MODE (cheap),
+                                               REGNO (cheap)))
                {
                  rtx dest, newpat;
                  rtx pat = PATTERN (insn);