CbC/CbC_gcc: gcc/compare-elim.c comparison

comparison gcc/compare-elim.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Post-reload compare elimination.
-Copyright (C) 2010-2017 Free Software Foundation, Inc.
+Copyright (C) 2010-2018 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
 /* The comparison instruction.  */
 rtx_insn *insn;
 /* The insn prior to the comparison insn that clobbers the flags.  */
 rtx_insn *prev_clobber;
+/* The insn prior to the comparison insn that sets in_a REG.  */
+rtx_insn *in_a_setter;
 /* The two values being compared.  These will be either REGs or
 constants.  */
 rtx in_a, in_b;
 in BB->AUX.  Called via dom_walker.walk ().  */
 edge
 find_comparison_dom_walker::before_dom_children (basic_block bb)
 {
-struct comparison *last_cmp;
+rtx_insn *insn, *next;
-rtx_insn *insn, *next, *last_clobber;
-bool last_cmp_valid;
 bool need_purge = false;
-bitmap killed;
+rtx_insn *last_setter[FIRST_PSEUDO_REGISTER];
-killed = BITMAP_ALLOC (NULL);
 /* The last comparison that was made.  Will be reset to NULL
 once the flags are clobbered.  */
-last_cmp = NULL;
+struct comparison *last_cmp = NULL;
 /* True iff the last comparison has not been clobbered, nor
 have its inputs.  Used to eliminate duplicate compares.  */
-last_cmp_valid = false;
+bool last_cmp_valid = false;
 /* The last insn that clobbered the flags, if that insn is of
 a form that may be valid for eliminating a following compare.
 To be reset to NULL once the flags are set otherwise.  */
-last_clobber = NULL;
+rtx_insn *last_clobber = NULL;
 /* Propagate the last live comparison throughout the extended basic block. */
 if (single_pred_p (bb))
 {
 last_cmp = (struct comparison *) single_pred (bb)->aux;
 if (last_cmp)
 	last_cmp_valid = last_cmp->inputs_valid;
 }
+memset (last_setter, 0, sizeof (last_setter));
 for (insn = BB_HEAD (bb); insn; insn = next)
 {
 rtx src;
 next = (insn == BB_END (bb) ? NULL : NEXT_INSN (insn));
 if (!NONDEBUG_INSN_P (insn))
 	continue;
-/* Compute the set of registers modified by this instruction.  */
-bitmap_clear (killed);
-df_simulate_find_defs (insn, killed);
 src = conforming_compare (insn);
 if (src)
 	{
 	  rtx eh_note = NULL;
 	  last_cmp->prev_clobber = last_clobber;
 	  last_cmp->in_a = XEXP (src, 0);
 	  last_cmp->in_b = XEXP (src, 1);
 	  last_cmp->eh_note = eh_note;
 	  last_cmp->orig_mode = GET_MODE (src);
+	  if (last_cmp->in_b == const0_rtx
+	      && last_setter[REGNO (last_cmp->in_a)])
+	    {
+	      rtx set = single_set (last_setter[REGNO (last_cmp->in_a)]);
+	      if (set && rtx_equal_p (SET_DEST (set), last_cmp->in_a))
+		last_cmp->in_a_setter = last_setter[REGNO (last_cmp->in_a)];
+	    }
 	  all_compares.safe_push (last_cmp);
 	  /* It's unusual, but be prepared for comparison patterns that
 	     also clobber an input, or perhaps a scratch.  */
 	  last_clobber = NULL;
 	  /* Notice if this instruction uses the flags register.  */
 	  if (last_cmp)
 	    find_flags_uses_in_insn (last_cmp, insn);
 	  /* Notice if this instruction kills the flags register.  */
-	  if (bitmap_bit_p (killed, targetm.flags_regnum))
+	  df_ref def;
-	    {
+	  FOR_EACH_INSN_DEF (def, insn)
-	      /* See if this insn could be the "clobber" that eliminates
+	    if (DF_REF_REGNO (def) == targetm.flags_regnum)
-		 a future comparison.   */
+	      {
-	      last_clobber = (arithmetic_flags_clobber_p (insn) ? insn : NULL);
+		/* See if this insn could be the "clobber" that eliminates
+		   a future comparison.   */
-	      /* In either case, the previous compare is no longer valid.  */
+		last_clobber = (arithmetic_flags_clobber_p (insn)
-	      last_cmp = NULL;
+				? insn : NULL);
-	      last_cmp_valid = false;
-	    }
+		/* In either case, the previous compare is no longer valid.  */
+		last_cmp = NULL;
+		last_cmp_valid = false;
+		break;
+	      }
 	}
-/* Notice if any of the inputs to the comparison have changed.  */
+/* Notice if any of the inputs to the comparison have changed
-if (last_cmp_valid
+	 and remember last insn that sets each register.  */
-	  && (bitmap_bit_p (killed, REGNO (last_cmp->in_a))
+df_ref def;
-	      || (REG_P (last_cmp->in_b)
+FOR_EACH_INSN_DEF (def, insn)
-		  && bitmap_bit_p (killed, REGNO (last_cmp->in_b)))))
+	{
-	last_cmp_valid = false;
+	  if (last_cmp_valid
-}
+	      && (DF_REF_REGNO (def) == REGNO (last_cmp->in_a)
+		  || (REG_P (last_cmp->in_b)
-BITMAP_FREE (killed);
+		      && DF_REF_REGNO (def) == REGNO (last_cmp->in_b))))
+	    last_cmp_valid = false;
+	  last_setter[DF_REF_REGNO (def)] = insn;
+	}
+}
 /* Remember the live comparison for subsequent members of
 the extended basic block.  */
 if (last_cmp)
 {
 if so.  Otherwise return NULL.  */
 static rtx
 try_validate_parallel (rtx set_a, rtx set_b)
 {
-rtx par
+rtx par = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set_a, set_b));
-= gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set_a, set_b));
+rtx_insn *insn = make_insn_raw (par);
-rtx_insn *insn;
+if (insn_invalid_p (insn, false))
-insn = gen_rtx_INSN (VOIDmode, 0, 0, 0, par, 0, -1, 0);
+{
+crtl->emit.x_cur_insn_uid--;
-return recog_memoized (insn) > 0 ? par : NULL_RTX;
+return NULL_RTX;
+}
+SET_PREV_INSN (insn) = NULL_RTX;
+SET_NEXT_INSN (insn) = NULL_RTX;
+INSN_LOCATION (insn) = 0;
+return insn;
 }
 /* For a comparison instruction described by CMP check if it compares a
 register with zero i.e. it is of the form CC := CMP R1, 0.
 If it is, find the instruction defining R1 (say I1) and try to create a
 arithmetic instruction.  Example:
 I1: R1 := R2 + R3
 <instructions that don't read the condition register>
 I2: CC := CMP R1 0
 I2 can be merged with I1 into:
-I1: { R1 := R2 + R3 ; CC := CMP (R2 + R3) 0 }
+I1: { CC := CMP (R2 + R3) 0 ; R1 := R2 + R3 }
 This catches cases where R1 is used between I1 and I2 and therefore
 combine and other RTL optimisations will not try to propagate it into
 I2.  Return true if we succeeded in merging CMP.  */
 static bool
 try_merge_compare (struct comparison *cmp)
 {
 rtx_insn *cmp_insn = cmp->insn;
-if (!REG_P (cmp->in_a) || cmp->in_b != const0_rtx)
+if (cmp->in_b != const0_rtx || cmp->in_a_setter == NULL)
 return false;
 rtx in_a = cmp->in_a;
 df_ref use;
 FOR_EACH_INSN_USE (use, cmp_insn)
 if (DF_REF_REGNO (use) == REGNO (in_a))
 break;
 if (!use)
 return false;
-/* Validate the data flow information before attempting to
+rtx_insn *def_insn = cmp->in_a_setter;
-find the instruction that defines in_a.  */
-struct df_link *ref_chain;
-ref_chain = DF_REF_CHAIN (use);
-if (!ref_chain || !ref_chain->ref
-|| !DF_REF_INSN_INFO (ref_chain->ref) || ref_chain->next != NULL)
-return false;
-rtx_insn *def_insn = DF_REF_INSN (ref_chain->ref);
-/* We found the insn that defines in_a.  Only consider the cases where
-it is in the same block as the comparison.  */
-if (BLOCK_FOR_INSN (cmp_insn) != BLOCK_FOR_INSN (def_insn))
-return false;
 rtx set = single_set (def_insn);
 if (!set)
 return false;
 if (!can_merge_compare_into_arith (cmp_insn, def_insn))
 return false;
 rtx src = SET_SRC (set);
+/* If the source uses addressing modes with side effects, we can't
+do the merge because we'd end up with a PARALLEL that has two
+instances of that side effect in it.  */
+if (side_effects_p (src))
+return false;
 rtx flags = maybe_select_cc_mode (cmp, src, CONST0_RTX (GET_MODE (src)));
 if (!flags)
 {
 /* We may already have a change group going through maybe_select_cc_mode.
 Discard it properly.  */
 cmp_src = in_a;
 else
 return false;
+/* If the source uses addressing modes with side effects, we can't
+do the merge because we'd end up with a PARALLEL that has two
+instances of that side effect in it.  */
+if (side_effects_p (cmp_src))
+return false;
 /* Determine if we ought to use a different CC_MODE here.  */
 flags = maybe_select_cc_mode (cmp, cmp_src, in_b);
 if (flags == NULL)
 flags = gen_rtx_REG (cmp->orig_mode, targetm.flags_regnum);
 /* Main entry point to the pass.  */
 static unsigned int
 execute_compare_elim_after_reload (void)
 {
-df_chain_add_problem (DF_UD_CHAIN + DF_DU_CHAIN);
 df_analyze ();
 gcc_checking_assert (!all_compares.exists ());
 /* Locate all comparisons and their uses, and eliminate duplicates.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/compare-elim.c @ 131:84e7813d76e9