CbC/CbC_gcc: gcc/cse.c comparison

comparison gcc/cse.c @ 146:351920fa3827

merge

author	anatofuz <anatofuz@cr.ie.u-ryukyu.ac.jp>
date	Sun, 01 Mar 2020 16:13:28 +0900
parents	1830386684a0
children

comparison

equal deleted inserted replaced

-:8f4e72ab4e11
+:351920fa3827
 /* Common subexpression elimination for GNU compiler.
-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 "cfgrtl.h"
 #include "cfganal.h"
 #include "cfgcleanup.h"
 #include "alias.h"
 #include "toplev.h"
-#include "params.h"
 #include "rtlhooks-def.h"
 #include "tree-pass.h"
 #include "dbgcnt.h"
 #include "rtl-iter.h"
+#include "regs.h"
+#include "function-abi.h"
 /* The basic idea of common subexpression elimination is to go
 through the code, keeping a record of expressions that would
 have the same value at the current scan point, and replacing
 expressions encountered with the cheapest equivalent expression.
 static struct table_elt *insert_with_costs (rtx, struct table_elt *, unsigned,
 					    machine_mode, int, int);
 static struct table_elt *insert (rtx, struct table_elt *, unsigned,
 				 machine_mode);
 static void merge_equiv_classes (struct table_elt *, struct table_elt *);
-static void invalidate_reg (rtx, bool);
 static void invalidate (rtx, machine_mode);
 static void remove_invalid_refs (unsigned int);
 static void remove_invalid_subreg_refs (unsigned int, poly_uint64,
 					machine_mode);
 static void rehash_using_reg (rtx);
 static void invalidate_memory (void);
-static void invalidate_for_call (void);
 static rtx use_related_value (rtx, struct table_elt *);
 static inline unsigned canon_hash (rtx, machine_mode);
 static inline unsigned safe_hash (rtx, machine_mode);
 static inline unsigned hash_rtx_string (const char *);
 }
 return false;
 }
 /* Remove from the hash table, or mark as invalid, all expressions whose
-values could be altered by storing in register X.
+values could be altered by storing in register X.  */
-CLOBBER_HIGH is set if X was part of a CLOBBER_HIGH expression.  */
 static void
-invalidate_reg (rtx x, bool clobber_high)
+invalidate_reg (rtx x)
 {
 gcc_assert (GET_CODE (x) == REG);
 /* If X is a register, dependencies on its contents are recorded
 through the qty number mechanism.  Just change the qty number of
 delete_reg_equiv (regno);
 REG_TICK (regno)++;
 SUBREG_TICKED (regno) = -1;
 if (regno >= FIRST_PSEUDO_REGISTER)
-{
+remove_pseudo_from_table (x, hash);
-gcc_assert (!clobber_high);
-remove_pseudo_from_table (x, hash);
-}
 else
 {
 HOST_WIDE_INT in_table = TEST_HARD_REG_BIT (hard_regs_in_table, regno);
 unsigned int endregno = END_REGNO (x);
 unsigned int rn;
 	      next = p->next_same_hash;
 	      if (!REG_P (p->exp) || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
 		continue;
-	      if (clobber_high)
+	      unsigned int tregno = REGNO (p->exp);
-		{
+	      unsigned int tendregno = END_REGNO (p->exp);
-		  if (reg_is_clobbered_by_clobber_high (p->exp, x))
+	      if (tendregno > regno && tregno < endregno)
-		    remove_from_table (p, hash);
+		remove_from_table (p, hash);
-		}
-	      else
-		{
-		  unsigned int tregno = REGNO (p->exp);
-		  unsigned int tendregno = END_REGNO (p->exp);
-		  if (tendregno > regno && tregno < endregno)
-		    remove_from_table (p, hash);
-		}
 	    }
 }
 }
 /* Remove from the hash table, or mark as invalid, all expressions whose
 rtx addr;
 switch (GET_CODE (x))
 {
 case REG:
-invalidate_reg (x, false);
+invalidate_reg (x);
 return;
 case SUBREG:
 invalidate (SUBREG_REG (x), VOIDmode);
 return;
 	  }
 }
 }
 /* Remove from the hash table any expression that is a call-clobbered
-register.  Also update their TICK values.  */
+register in INSN.  Also update their TICK values.  */
 static void
-invalidate_for_call (void)
+invalidate_for_call (rtx_insn *insn)
 {
-unsigned int regno, endregno;
+unsigned int regno;
-unsigned int i;
 unsigned hash;
 struct table_elt *p, *next;
 int in_table = 0;
 hard_reg_set_iterator hrsi;
-/* Go through all the hard registers.  For each that is clobbered in
+/* Go through all the hard registers.  For each that might be clobbered
-a CALL_INSN, remove the register from quantity chains and update
+in call insn INSN, remove the register from quantity chains and update
 reg_tick if defined.  Also see if any of these registers is currently
-in the table.  */
+in the table.
-EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, regno, hrsi)
+??? We could be more precise for partially-clobbered registers,
+and only invalidate values that actually occupy the clobbered part
+of the registers.  It doesn't seem worth the effort though, since
+we shouldn't see this situation much before RA.  Whatever choice
+we make here has to be consistent with the table walk below,
+so any change to this test will require a change there too.  */
+HARD_REG_SET callee_clobbers
+= insn_callee_abi (insn).full_and_partial_reg_clobbers ();
+EXECUTE_IF_SET_IN_HARD_REG_SET (callee_clobbers, 0, regno, hrsi)
 {
 delete_reg_equiv (regno);
 if (REG_TICK (regno) >= 0)
 	{
 	  REG_TICK (regno)++;
 	  if (!REG_P (p->exp)
 	      || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
 	    continue;
-	  regno = REGNO (p->exp);
+	  /* This must use the same test as above rather than the
-	  endregno = END_REGNO (p->exp);
+	     more accurate clobbers_reg_p.  */
+	  if (overlaps_hard_reg_set_p (callee_clobbers, GET_MODE (p->exp),
-	  for (i = regno; i < endregno; i++)
+				       REGNO (p->exp)))
-	    if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
+	    remove_from_table (p, hash);
-	      {
-		remove_from_table (p, hash);
-		break;
-	      }
 	}
 }
 /* Given an expression X of type CONST,
 and ELT which is its table entry (or 0 if it
 	 This does nothing when a register is clobbered
 	 because we have already invalidated the reg.  */
 if (MEM_P (XEXP (x, 0)))
 	canon_reg (XEXP (x, 0), insn);
 }
-else if (GET_CODE (x) == CLOBBER_HIGH)
-gcc_assert (REG_P (XEXP (x, 0)));
 else if (GET_CODE (x) == USE
 	   && ! (REG_P (XEXP (x, 0))
 		 && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER))
 /* Canonicalize a USE of a pseudo register or memory location.  */
 canon_reg (x, insn);
 	  else if (GET_CODE (y) == CLOBBER)
 	    {
 	      if (MEM_P (XEXP (y, 0)))
 		canon_reg (XEXP (y, 0), insn);
 	    }
-	  else if (GET_CODE (y) == CLOBBER_HIGH)
-	    gcc_assert (REG_P (XEXP (y, 0)));
 	  else if (GET_CODE (y) == USE
 		   && ! (REG_P (XEXP (y, 0))
 			 && REGNO (XEXP (y, 0)) < FIRST_PSEUDO_REGISTER))
 	    canon_reg (y, insn);
 	  else if (GET_CODE (y) == ASM_OPERANDS)
 	  else
 	    {
 	      trial = elt->exp;
 	      elt = elt->next_same_value;
 	      src_elt_cost = MAX_COST;
-	    }
-	  /* Avoid creation of overlapping memory moves.  */
-	  if (MEM_P (trial) && MEM_P (dest) && !rtx_equal_p (trial, dest))
-	    {
-	      rtx src, dest;
-	      /* BLKmode moves are not handled by cse anyway.  */
-	      if (GET_MODE (trial) == BLKmode)
-		break;
-	      src = canon_rtx (trial);
-	      dest = canon_rtx (SET_DEST (sets[i].rtl));
-	      if (!MEM_P (src) || !MEM_P (dest)
-		  || !nonoverlapping_memrefs_p (src, dest, false))
-		break;
 	    }
 	  /* Try to optimize
 	     (set (reg:M N) (const_int A))
 	     (set (reg:M2 O) (const_int B))
 			   && GET_CODE (XEXP (XEXP (trial, 0), 0)) == LABEL_REF
 			   && GET_CODE (XEXP (XEXP (trial, 0), 1)) == LABEL_REF)))
 	    /* Do nothing for this case.  */
 	    ;
+	  /* Do not replace anything with a MEM, except the replacement
+	     is a no-op.  This allows this loop to terminate.  */
+	  else if (MEM_P (trial) && !rtx_equal_p (trial, SET_SRC(sets[i].rtl)))
+	    /* Do nothing for this case.  */
+	    ;
 	  /* Look for a substitution that makes a valid insn.  */
 	  else if (validate_unshare_change (insn, &SET_SRC (sets[i].rtl),
 					    trial, 0))
 	    {
 	      rtx new_rtx = canon_reg (SET_SRC (sets[i].rtl), insn);
 	   those are owned by the callee.  */
 	for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1))
 	  if (GET_CODE (XEXP (tem, 0)) == USE
 	      && MEM_P (XEXP (XEXP (tem, 0), 0)))
 	    invalidate (XEXP (XEXP (tem, 0), 0), VOIDmode);
-invalidate_for_call ();
+invalidate_for_call (insn);
 }
 /* Now invalidate everything set by this instruction.
 If a SUBREG or other funny destination is being set,
 sets[i].rtl is still nonzero, so here we invalidate the reg
 	  else if (GET_CODE (ref) == STRICT_LOW_PART
 		   || GET_CODE (ref) == ZERO_EXTRACT)
 	    invalidate (XEXP (ref, 0), GET_MODE (ref));
 	}
 }
-if (GET_CODE (x) == CLOBBER_HIGH)
-{
-rtx ref = XEXP (x, 0);
-gcc_assert (REG_P (ref));
-invalidate_reg (ref, true);
-}
 else if (GET_CODE (x) == PARALLEL)
 {
 int i;
 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
 	{
 		invalidate (ref, VOIDmode);
 	      else if (GET_CODE (ref) == STRICT_LOW_PART
 		       || GET_CODE (ref) == ZERO_EXTRACT)
 		invalidate (XEXP (ref, 0), GET_MODE (ref));
 	    }
-	  else if (GET_CODE (y) == CLOBBER_HIGH)
-	    {
-	      rtx ref = XEXP (y, 0);
-	      gcc_assert (REG_P (ref));
-	      invalidate_reg (ref, true);
-	    }
 	}
 }
 }
 /* Perform invalidation on the basis of everything about INSN.
 for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1))
 	{
 	  rtx temx = XEXP (tem, 0);
 	  if (GET_CODE (temx) == CLOBBER)
 	    invalidate (SET_DEST (temx), VOIDmode);
-	  else if (GET_CODE (temx) == CLOBBER_HIGH)
-	    {
-	      rtx temref = XEXP (temx, 0);
-	      gcc_assert (REG_P (temref));
-	      invalidate_reg (temref, true);
-	    }
 	}
 }
 /* Ensure we invalidate the destination register of a CALL insn.
 This is necessary for machines where this register is a fixed_reg,
 		  || GET_CODE (clobbered) == SUBREG)
 		invalidate (clobbered, VOIDmode);
 	      else if (GET_CODE (clobbered) == STRICT_LOW_PART
 		       || GET_CODE (clobbered) == ZERO_EXTRACT)
 		invalidate (XEXP (clobbered, 0), GET_MODE (clobbered));
-	    }
-	  else if (GET_CODE (y) == CLOBBER_HIGH)
-	    {
-	      rtx ref = XEXP (y, 0);
-	      gcc_assert (REG_P (ref));
-	      invalidate_reg (ref, true);
 	    }
 	  else if (GET_CODE (y) == SET && GET_CODE (SET_SRC (y)) == CALL)
 	    invalidate (SET_DEST (y), VOIDmode);
 	}
 }
 /* Extend the path if possible.  */
 if (follow_jumps)
 {
 bb = data->path[path_size - 1].bb;
-while (bb && path_size < PARAM_VALUE (PARAM_MAX_CSE_PATH_LENGTH))
+while (bb && path_size < param_max_cse_path_length)
 	{
 	  if (single_succ_p (bb))
 	    e = single_succ_edge (bb);
 	  else if (EDGE_COUNT (bb->succs) == 2
 		   && any_condjump_p (BB_END (bb)))
 int path_entry;
 fprintf (f, ";; Following path with %d sets: ", nsets);
 for (path_entry = 0; path_entry < data->path_size; path_entry++)
 fprintf (f, "%d ", (data->path[path_entry].bb)->index);
-fputc ('\n', dump_file);
+fputc ('\n', f);
 fflush (f);
 }
 /* Return true if BB has exception handling successor edges.  */
 	     generated with -O but not -g.
 	     FIXME: This is a real kludge and needs to be done some other
 		    way.  */
 	  if (NONDEBUG_INSN_P (insn)
-	      && num_insns++ > PARAM_VALUE (PARAM_MAX_CSE_INSNS))
+	      && num_insns++ > param_max_cse_insns)
 	    {
 	      flush_hash_table ();
 	      num_insns = 0;
 	    }
 reg_scan (get_insns (), max_reg_num ());
 init_cse_reg_info (nregs);
 ebb_data.path = XNEWVEC (struct branch_path,
-			   PARAM_VALUE (PARAM_MAX_CSE_PATH_LENGTH));
+			   param_max_cse_path_length);
 cse_cfg_altered = false;
 cse_jumps_altered = false;
 recorded_label_ref = false;
 constant_pool_entries_cost = 0;
 case CLOBBER:
 /* If we are clobbering a MEM, mark any registers inside the address
 as being used.  */
 if (MEM_P (XEXP (x, 0)))
 	count_reg_usage (XEXP (XEXP (x, 0), 0), counts, NULL_RTX, incr);
-return;
-case CLOBBER_HIGH:
-gcc_assert (REG_P ((XEXP (x, 0))));
 return;
 case SET:
 /* Unless we are setting a REG, count everything in SET_DEST.  */
 if (!REG_P (SET_DEST (x)))
 case EXPR_LIST:
 if (REG_NOTE_KIND (x) == REG_EQUAL
 	  || (REG_NOTE_KIND (x) != REG_NONNEG && GET_CODE (XEXP (x,0)) == USE)
 	  /* FUNCTION_USAGE expression lists may include (CLOBBER (mem /u)),
 	     involving registers in the address.  */
-	  || GET_CODE (XEXP (x, 0)) == CLOBBER
+	  || GET_CODE (XEXP (x, 0)) == CLOBBER)
-	  || GET_CODE (XEXP (x, 0)) == CLOBBER_HIGH)
 	count_reg_usage (XEXP (x, 0), counts, NULL_RTX, incr);
 count_reg_usage (XEXP (x, 1), counts, NULL_RTX, incr);
 return;
 	  if (GET_CODE (elt) == SET)
 	    {
 	      if (set_live_p (elt, insn, counts))
 		return true;
 	    }
-	  else if (GET_CODE (elt) != CLOBBER
+	  else if (GET_CODE (elt) != CLOBBER && GET_CODE (elt) != USE)
-		   && GET_CODE (elt) != CLOBBER_HIGH
-		   && GET_CODE (elt) != USE)
 	    return true;
 	}
 return false;
 }
 else if (DEBUG_INSN_P (insn))
 	  count_reg_usage (INSN_VAR_LOCATION_LOC (insn), counts + nreg,
 			   NULL_RTX, 1);
 	else if (INSN_P (insn))
 	  {
 	    count_reg_usage (insn, counts, NULL_RTX, 1);
-	    note_stores (PATTERN (insn), count_stores, counts + nreg * 2);
+	    note_stores (insn, count_stores, counts + nreg * 2);
 	  }
 /* If there can be debug insns, COUNTS are 3 consecutive arrays.
 	 First one counts how many times each pseudo is used outside
 	 of debug insns, second counts how many times each pseudo is
 	 used in debug insns and third counts how many times a pseudo
 timevar_push (TV_JUMP);
 rebuild_jump_labels (get_insns ());
 cse_cfg_altered |= cleanup_cfg (CLEANUP_CFG_CHANGED);
 timevar_pop (TV_JUMP);
 }
-else if (tem == 1)
+else if (tem == 1 || cse_cfg_altered)
 cse_cfg_altered |= cleanup_cfg (0);
 cse_not_expected = 1;
 return 0;
 }
 timevar_push (TV_JUMP);
 rebuild_jump_labels (get_insns ());
 cse_cfg_altered |= cleanup_cfg (CLEANUP_CFG_CHANGED);
 timevar_pop (TV_JUMP);
 }
-else if (tem == 1)
+else if (tem == 1 || cse_cfg_altered)
 cse_cfg_altered |= cleanup_cfg (0);
 flag_cse_follow_jumps = save_cfj;
 return 0;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cse.c @ 146:351920fa3827