CbC/CbC_gcc: gcc/reginfo.c comparison

comparison gcc/reginfo.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Compute different info about registers.
-Copyright (C) 1987-2018 Free Software Foundation, Inc.
+Copyright (C) 1987-2020 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 #include "recog.h"
 #include "diagnostic-core.h"
 #include "reload.h"
 #include "output.h"
 #include "tree-pass.h"
+#include "function-abi.h"
 /* Maximum register number used in this function, plus one.  */
 int max_regno;
 /* Used to cache the results of simplifiable_subregs.  SHAPE is the input
 parameter and SIMPLIFIABLE_REGS is the result.  */
-struct simplifiable_subreg
+class simplifiable_subreg
 {
+public:
 simplifiable_subreg (const subreg_shape &);
 subreg_shape shape;
 HARD_REG_SET simplifiable_regs;
 };
 #if SWITCHABLE_TARGET
 struct target_hard_regs *this_target_hard_regs = &default_target_hard_regs;
 struct target_regs *this_target_regs = &default_target_regs;
 #endif
+#define call_used_regs \
+(this_target_hard_regs->x_call_used_regs)
+#define regs_invalidated_by_call \
+(this_target_hard_regs->x_regs_invalidated_by_call)
 /* Data for initializing fixed_regs.  */
 static const char initial_fixed_regs[] = FIXED_REGISTERS;
 /* Data for initializing call_used_regs.  */
+#ifdef CALL_REALLY_USED_REGISTERS
+#ifdef CALL_USED_REGISTERS
+#error CALL_USED_REGISTERS and CALL_REALLY_USED_REGISTERS are both defined
+#endif
+static const char initial_call_used_regs[] = CALL_REALLY_USED_REGISTERS;
+#else
 static const char initial_call_used_regs[] = CALL_USED_REGISTERS;
-#ifdef CALL_REALLY_USED_REGISTERS
-/* Data for initializing call_really_used_regs.  */
-static const char initial_call_really_used_regs[] = CALL_REALLY_USED_REGISTERS;
-#endif
-#ifdef CALL_REALLY_USED_REGISTERS
-#define CALL_REALLY_USED_REGNO_P(X)  call_really_used_regs[X]
-#else
-#define CALL_REALLY_USED_REGNO_P(X)  call_used_regs[X]
 #endif
 /* Indexed by hard register number, contains 1 for registers
 that are being used for global register decls.
 These must be exempt from ordinary flow analysis
 and are also considered fixed.  */
 char global_regs[FIRST_PSEUDO_REGISTER];
 /* Declaration for the global register. */
 tree global_regs_decl[FIRST_PSEUDO_REGISTER];
-/* Same information as REGS_INVALIDATED_BY_CALL but in regset form to be used
-in dataflow more conveniently.  */
-regset regs_invalidated_by_call_regset;
-/* Same information as FIXED_REG_SET but in regset form.  */
-regset fixed_reg_set_regset;
-/* The bitmap_obstack is used to hold some static variables that
-should not be reset after each function is compiled.  */
-static bitmap_obstack persistent_obstack;
 /* Used to initialize reg_alloc_order.  */
 #ifdef REG_ALLOC_ORDER
 static int initial_reg_alloc_order[FIRST_PSEUDO_REGISTER] = REG_ALLOC_ORDER;
 #endif
 /* Sanity check: make sure the target macros FIXED_REGISTERS and
 CALL_USED_REGISTERS had the right number of initializers.  */
 gcc_assert (sizeof fixed_regs == sizeof initial_fixed_regs);
 gcc_assert (sizeof call_used_regs == sizeof initial_call_used_regs);
-#ifdef CALL_REALLY_USED_REGISTERS
-gcc_assert (sizeof call_really_used_regs
-	      == sizeof initial_call_really_used_regs);
-#endif
 #ifdef REG_ALLOC_ORDER
 gcc_assert (sizeof reg_alloc_order == sizeof initial_reg_alloc_order);
 #endif
 gcc_assert (sizeof reg_names == sizeof initial_reg_names);
 memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
 memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
-#ifdef CALL_REALLY_USED_REGISTERS
-memcpy (call_really_used_regs, initial_call_really_used_regs,
-	  sizeof call_really_used_regs);
-#endif
 #ifdef REG_ALLOC_ORDER
 memcpy (reg_alloc_order, initial_reg_alloc_order, sizeof reg_alloc_order);
 #endif
 memcpy (reg_names, initial_reg_names, sizeof reg_names);
 /* We need to save copies of some of the register information which
 can be munged by command-line switches so we can restore it during
 subsequent back-end reinitialization.  */
 static char saved_fixed_regs[FIRST_PSEUDO_REGISTER];
 static char saved_call_used_regs[FIRST_PSEUDO_REGISTER];
-#ifdef CALL_REALLY_USED_REGISTERS
-static char saved_call_really_used_regs[FIRST_PSEUDO_REGISTER];
-#endif
 static const char *saved_reg_names[FIRST_PSEUDO_REGISTER];
 static HARD_REG_SET saved_accessible_reg_set;
 static HARD_REG_SET saved_operand_reg_set;
 /* Save the register information.  */
 gcc_assert (sizeof fixed_regs == sizeof saved_fixed_regs);
 gcc_assert (sizeof call_used_regs == sizeof saved_call_used_regs);
 memcpy (saved_fixed_regs, fixed_regs, sizeof fixed_regs);
 memcpy (saved_call_used_regs, call_used_regs, sizeof call_used_regs);
-/* Likewise for call_really_used_regs.  */
-#ifdef CALL_REALLY_USED_REGISTERS
-gcc_assert (sizeof call_really_used_regs
-	      == sizeof saved_call_really_used_regs);
-memcpy (saved_call_really_used_regs, call_really_used_regs,
-	  sizeof call_really_used_regs);
-#endif
 /* And similarly for reg_names.  */
 gcc_assert (sizeof reg_names == sizeof saved_reg_names);
 memcpy (saved_reg_names, reg_names, sizeof reg_names);
-COPY_HARD_REG_SET (saved_accessible_reg_set, accessible_reg_set);
+saved_accessible_reg_set = accessible_reg_set;
-COPY_HARD_REG_SET (saved_operand_reg_set, operand_reg_set);
+saved_operand_reg_set = operand_reg_set;
 }
 /* Restore the register information.  */
 static void
 restore_register_info (void)
 {
 memcpy (fixed_regs, saved_fixed_regs, sizeof fixed_regs);
 memcpy (call_used_regs, saved_call_used_regs, sizeof call_used_regs);
-#ifdef CALL_REALLY_USED_REGISTERS
-memcpy (call_really_used_regs, saved_call_really_used_regs,
-	  sizeof call_really_used_regs);
-#endif
 memcpy (reg_names, saved_reg_names, sizeof reg_names);
-COPY_HARD_REG_SET (accessible_reg_set, saved_accessible_reg_set);
+accessible_reg_set = saved_accessible_reg_set;
-COPY_HARD_REG_SET (operand_reg_set, saved_operand_reg_set);
+operand_reg_set = saved_operand_reg_set;
 }
 /* After switches have been processed, which perhaps alter
 `fixed_regs' and `call_used_regs', convert them to HARD_REG_SETs.  */
 static void
 for (j = 0; j < N_REG_CLASSES; j++)
 	{
 	  HARD_REG_SET c;
 	  int k;
-	  COPY_HARD_REG_SET (c, reg_class_contents[i]);
+	  c = reg_class_contents[i] | reg_class_contents[j];
-	  IOR_HARD_REG_SET (c, reg_class_contents[j]);
 	  for (k = 0; k < N_REG_CLASSES; k++)
 	    if (hard_reg_set_subset_p (reg_class_contents[k], c)
 		&& !hard_reg_set_subset_p (reg_class_contents[k],
 					  reg_class_contents
 					  [(int) reg_class_subunion[i][j]]))
 for (j = 0; j < N_REG_CLASSES; j++)
 	{
 	  HARD_REG_SET c;
 	  int k;
-	  COPY_HARD_REG_SET (c, reg_class_contents[i]);
+	  c = reg_class_contents[i] | reg_class_contents[j];
-	  IOR_HARD_REG_SET (c, reg_class_contents[j]);
 	  for (k = 0; k < N_REG_CLASSES; k++)
 	    if (hard_reg_set_subset_p (c, reg_class_contents[k]))
 	      break;
 	  reg_class_superunion[i][j] = (enum reg_class) k;
 }
 /* Initialize "constant" tables.  */
 CLEAR_HARD_REG_SET (fixed_reg_set);
-CLEAR_HARD_REG_SET (call_used_reg_set);
-CLEAR_HARD_REG_SET (call_fixed_reg_set);
 CLEAR_HARD_REG_SET (regs_invalidated_by_call);
-if (!regs_invalidated_by_call_regset)
-{
+operand_reg_set &= accessible_reg_set;
-bitmap_obstack_initialize (&persistent_obstack);
-regs_invalidated_by_call_regset = ALLOC_REG_SET (&persistent_obstack);
-}
-else
-CLEAR_REG_SET (regs_invalidated_by_call_regset);
-if (!fixed_reg_set_regset)
-fixed_reg_set_regset = ALLOC_REG_SET (&persistent_obstack);
-else
-CLEAR_REG_SET (fixed_reg_set_regset);
-AND_HARD_REG_SET (operand_reg_set, accessible_reg_set);
 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 {
 /* As a special exception, registers whose class is NO_REGS are
 	 not accepted by `register_operand'.  The reason for this change
 	 is to allow the representation of special architecture artifacts
 	CLEAR_HARD_REG_BIT (operand_reg_set, i);
 /* If a register is too limited to be treated as a register operand,
 	 then it should never be allocated to a pseudo.  */
 if (!TEST_HARD_REG_BIT (operand_reg_set, i))
-	{
+	fixed_regs[i] = 1;
-	  fixed_regs[i] = 1;
-	  call_used_regs[i] = 1;
-	}
-/* call_used_regs must include fixed_regs.  */
-gcc_assert (!fixed_regs[i] || call_used_regs[i]);
-#ifdef CALL_REALLY_USED_REGISTERS
-/* call_used_regs must include call_really_used_regs.  */
-gcc_assert (!call_really_used_regs[i] || call_used_regs[i]);
-#endif
 if (fixed_regs[i])
-	{
+	SET_HARD_REG_BIT (fixed_reg_set, i);
-	  SET_HARD_REG_BIT (fixed_reg_set, i);
-	  SET_REGNO_REG_SET (fixed_reg_set_regset, i);
-	}
-if (call_used_regs[i])
-	SET_HARD_REG_BIT (call_used_reg_set, i);
 /* There are a couple of fixed registers that we know are safe to
 	 exclude from being clobbered by calls:
 	 The frame pointer is always preserved across calls.  The arg
 	 target can override that.  */
 if (i == STACK_POINTER_REGNUM)
 	;
 else if (global_regs[i])
-{
+	SET_HARD_REG_BIT (regs_invalidated_by_call, i);
-	  SET_HARD_REG_BIT (regs_invalidated_by_call, i);
-	  SET_REGNO_REG_SET (regs_invalidated_by_call_regset, i);
-	}
 else if (i == FRAME_POINTER_REGNUM)
 	;
 else if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
 	       && i == HARD_FRAME_POINTER_REGNUM)
 	;
 	       && i == ARG_POINTER_REGNUM && fixed_regs[i])
 	;
 else if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
 	       && i == (unsigned) PIC_OFFSET_TABLE_REGNUM && fixed_regs[i])
 	;
-else if (CALL_REALLY_USED_REGNO_P (i))
+else if (call_used_regs[i])
-{
+	SET_HARD_REG_BIT (regs_invalidated_by_call, i);
-	  SET_HARD_REG_BIT (regs_invalidated_by_call, i);
+}
-	  SET_REGNO_REG_SET (regs_invalidated_by_call_regset, i);
-}
+SET_HARD_REG_SET (savable_regs);
-}
+fixed_nonglobal_reg_set = fixed_reg_set;
-COPY_HARD_REG_SET (call_fixed_reg_set, fixed_reg_set);
-COPY_HARD_REG_SET (fixed_nonglobal_reg_set, fixed_reg_set);
 /* Preserve global registers if called more than once.  */
 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 {
 if (global_regs[i])
 	{
 	  fixed_regs[i] = call_used_regs[i] = 1;
 	  SET_HARD_REG_BIT (fixed_reg_set, i);
-	  SET_HARD_REG_BIT (call_used_reg_set, i);
-	  SET_HARD_REG_BIT (call_fixed_reg_set, i);
 	}
 }
 memset (have_regs_of_mode, 0, sizeof (have_regs_of_mode));
 memset (contains_reg_of_mode, 0, sizeof (contains_reg_of_mode));
 		 have_regs_of_mode[m] = 1;
 		 contains_allocatable_reg_of_mode[i][m] = 1;
 	       }
 	  }
 }
+default_function_abi.initialize (0, regs_invalidated_by_call);
 }
 /* Compute the table of register modes.
 These values are used to record death information for individual registers
 (as opposed to a multi-register mode).
 this_target_regs->x_hard_regno_nregs[i][j]
 	= targetm.hard_regno_nregs (i, (machine_mode) j);
 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 {
-reg_raw_mode[i] = choose_hard_reg_mode (i, 1, false);
+reg_raw_mode[i] = choose_hard_reg_mode (i, 1, NULL);
 /* If we couldn't find a valid mode, just use the previous mode
 	 if it is suitable, otherwise fall back on word_mode.  */
 if (reg_raw_mode[i] == VOIDmode)
 	{
 return memory_move_secondary_cost (mode, altclass, in) + partial_cost;
 }
 /* Return a machine mode that is legitimate for hard reg REGNO and large
 enough to save nregs.  If we can't find one, return VOIDmode.
-If CALL_SAVED is true, only consider modes that are call saved.  */
+If ABI is nonnull, only consider modes that are preserved across
+calls that use ABI.  */
 machine_mode
 choose_hard_reg_mode (unsigned int regno ATTRIBUTE_UNUSED,
-		      unsigned int nregs, bool call_saved)
+		      unsigned int nregs, const predefined_function_abi *abi)
 {
 unsigned int /* machine_mode */ m;
 machine_mode found_mode = VOIDmode, mode;
 /* We first look for the largest integer mode that can be validly
 The tests use maybe_gt rather than known_gt because we want (for example)
 N V4SFs to win over plain V4SF even though N might be 1.  */
 FOR_EACH_MODE_IN_CLASS (mode, MODE_INT)
 if (hard_regno_nregs (regno, mode) == nregs
 	&& targetm.hard_regno_mode_ok (regno, mode)
-	&& (!call_saved
+	&& (!abi || !abi->clobbers_reg_p (mode, regno))
-	    || !targetm.hard_regno_call_part_clobbered (regno, mode))
 	&& maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
 found_mode = mode;
 FOR_EACH_MODE_IN_CLASS (mode, MODE_FLOAT)
 if (hard_regno_nregs (regno, mode) == nregs
 	&& targetm.hard_regno_mode_ok (regno, mode)
-	&& (!call_saved
+	&& (!abi || !abi->clobbers_reg_p (mode, regno))
-	    || !targetm.hard_regno_call_part_clobbered (regno, mode))
 	&& maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
 found_mode = mode;
 FOR_EACH_MODE_IN_CLASS (mode, MODE_VECTOR_FLOAT)
 if (hard_regno_nregs (regno, mode) == nregs
 	&& targetm.hard_regno_mode_ok (regno, mode)
-	&& (!call_saved
+	&& (!abi || !abi->clobbers_reg_p (mode, regno))
-	    || !targetm.hard_regno_call_part_clobbered (regno, mode))
 	&& maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
 found_mode = mode;
 FOR_EACH_MODE_IN_CLASS (mode, MODE_VECTOR_INT)
 if (hard_regno_nregs (regno, mode) == nregs
 	&& targetm.hard_regno_mode_ok (regno, mode)
-	&& (!call_saved
+	&& (!abi || !abi->clobbers_reg_p (mode, regno))
-	    || !targetm.hard_regno_call_part_clobbered (regno, mode))
 	&& maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
 found_mode = mode;
 if (found_mode != VOIDmode)
 return found_mode;
 for (m = (unsigned int) CCmode; m < (unsigned int) NUM_MACHINE_MODES; ++m)
 {
 mode = (machine_mode) m;
 if (hard_regno_nregs (regno, mode) == nregs
 	  && targetm.hard_regno_mode_ok (regno, mode)
-	  && (!call_saved
+	  && (!abi || !abi->clobbers_reg_p (mode, regno)))
-	      || !targetm.hard_regno_call_part_clobbered (regno, mode)))
 	return mode;
 }
 /* We can't find a mode valid for this register.  */
 return VOIDmode;
 		{
 		case 0:
 		  switch (call_used)
 		    {
 		    case 0:
-		      error ("can%'t use %qs as a call-saved register", name);
+		      error ("cannot use %qs as a call-saved register", name);
 		      break;
 		    case 1:
-		      error ("can%'t use %qs as a call-used register", name);
+		      error ("cannot use %qs as a call-used register", name);
 		      break;
 		    default:
 		      gcc_unreachable ();
 		    }
 		case 1:
 		  switch (call_used)
 		    {
 		    case 1:
-		      error ("can%'t use %qs as a fixed register", name);
+		      error ("cannot use %qs as a fixed register", name);
 		      break;
 		    case 0:
 		    default:
 		      gcc_unreachable ();
 		}
 	    }
 	  else
 	    {
 	      fixed_regs[i] = fixed;
-	      call_used_regs[i] = call_used;
 #ifdef CALL_REALLY_USED_REGISTERS
 	      if (fixed == 0)
-		call_really_used_regs[i] = call_used;
+		call_used_regs[i] = call_used;
+#else
+	      call_used_regs[i] = call_used;
 #endif
 	    }
 	}
 }
 else
 appropriate regs_invalidated_by_call bit, even if it's already
 set in fixed_regs.  */
 if (i != STACK_POINTER_REGNUM)
 {
 SET_HARD_REG_BIT (regs_invalidated_by_call, i);
-SET_REGNO_REG_SET (regs_invalidated_by_call_regset, i);
+for (unsigned int j = 0; j < NUM_ABI_IDS; ++j)
+	function_abis[j].add_full_reg_clobber (i);
 }
 /* If already fixed, nothing else to do.  */
 if (fixed_regs[i])
 return;
 fixed_regs[i] = call_used_regs[i] = 1;
-#ifdef CALL_REALLY_USED_REGISTERS
-call_really_used_regs[i] = 1;
-#endif
 SET_HARD_REG_BIT (fixed_reg_set, i);
-SET_HARD_REG_BIT (call_used_reg_set, i);
-SET_HARD_REG_BIT (call_fixed_reg_set, i);
 reinit_regs ();
 }
 break;
 case CLOBBER:
 if (MEM_P (XEXP (x, 0)))
 	reg_scan_mark_refs (XEXP (XEXP (x, 0), 0), insn);
-break;
-case CLOBBER_HIGH:
-gcc_assert (!(MEM_P (XEXP (x, 0))));
 break;
 case SET:
 /* Count a set of the destination if it is a register.  */
 for (dest = SET_DEST (x);
 else
 	shape.offset += size;
 }
 if (valid_mode_changes[regno])
-AND_HARD_REG_SET (*valid_mode_changes[regno],
+*valid_mode_changes[regno] &= simplifiable_subregs (shape);
-		      simplifiable_subregs (shape));
 else
 {
 valid_mode_changes[regno]
 	= XOBNEW (&valid_mode_changes_obstack, HARD_REG_SET);
-COPY_HARD_REG_SET (*valid_mode_changes[regno],
+*valid_mode_changes[regno] = simplifiable_subregs (shape);
-			 simplifiable_subregs (shape));
 }
 }
 /* Call record_subregs_of_mode for all the subregs in X.  */
 static void

Mercurial > hg > CbC > CbC_gcc

comparison gcc/reginfo.c @ 145:1830386684a0