CbC/CbC_gcc: gcc/loop-unroll.c comparison

comparison gcc/loop-unroll.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children	f6334be47118

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* Loop unrolling and peeling.
-Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
+Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2010
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "params.h"
 #include "output.h"
 #include "expr.h"
 #include "hashtab.h"
 #include "recog.h"
+#include "target.h"
 /* This pass performs loop unrolling and peeling.  We only perform these
 optimizations on innermost loops (with single exception) because
 the impact on performance is greatest here, and we want to avoid
 unnecessary code size growth.  The gain is caused by greater sequentiality
 static struct opt_info *analyze_insns_in_loop (struct loop *);
 static void opt_info_start_duplication (struct opt_info *);
 static void apply_opt_in_copies (struct opt_info *, unsigned, bool, bool);
 static void free_opt_info (struct opt_info *);
 static struct var_to_expand *analyze_insn_to_expand_var (struct loop*, rtx);
-static bool referenced_in_one_insn_in_loop_p (struct loop *, rtx);
+static bool referenced_in_one_insn_in_loop_p (struct loop *, rtx, int *);
 static struct iv_to_split *analyze_iv_to_split_insn (rtx);
 static void expand_var_during_unrolling (struct var_to_expand *, rtx);
 static void insert_var_expansion_initialization (struct var_to_expand *,
 						 basic_block);
 static void combine_var_copies_in_loop_exit (struct var_to_expand *,
 if (nunroll > nunroll_by_av)
 nunroll = nunroll_by_av;
 if (nunroll > (unsigned) PARAM_VALUE (PARAM_MAX_UNROLL_TIMES))
 nunroll = PARAM_VALUE (PARAM_MAX_UNROLL_TIMES);
+if (targetm.loop_unroll_adjust)
+nunroll = targetm.loop_unroll_adjust (nunroll, loop);
 /* Skip big loops.  */
 if (nunroll <= 1)
 {
 if (dump_file)
 	fprintf (dump_file, ";; Not considering loop, is too big\n");
 if (nunroll > nunroll_by_av)
 nunroll = nunroll_by_av;
 if (nunroll > (unsigned) PARAM_VALUE (PARAM_MAX_UNROLL_TIMES))
 nunroll = PARAM_VALUE (PARAM_MAX_UNROLL_TIMES);
+if (targetm.loop_unroll_adjust)
+nunroll = targetm.loop_unroll_adjust (nunroll, loop);
 /* Skip big loops.  */
 if (nunroll <= 1)
 {
 if (dump_file)
 	fprintf (dump_file, ";; Not considering loop, is too big\n");
 const struct var_to_expand *const i2 = (const struct var_to_expand *) ivts2;
 return i1->insn == i2->insn;
 }
-/* Returns true if REG is referenced in one insn in LOOP.  */
+/* Returns true if REG is referenced in one nondebug insn in LOOP.
+Set *DEBUG_USES to the number of debug insns that reference the
+variable.  */
 bool
-referenced_in_one_insn_in_loop_p (struct loop *loop, rtx reg)
+referenced_in_one_insn_in_loop_p (struct loop *loop, rtx reg,
+				  int *debug_uses)
 {
 basic_block *body, bb;
 unsigned i;
 int count_ref = 0;
 rtx insn;
 for (i = 0; i < loop->num_nodes; i++)
 {
 bb = body[i];
 FOR_BB_INSNS (bb, insn)
-{
+	if (!rtx_referenced_p (reg, insn))
-if (rtx_referenced_p (reg, insn))
+	  continue;
-count_ref++;
+	else if (DEBUG_INSN_P (insn))
-}
+	  ++*debug_uses;
-}
+	else if (++count_ref > 1)
+	  break;
+}
+free (body);
 return (count_ref  == 1);
+}
+/* Reset the DEBUG_USES debug insns in LOOP that reference REG.  */
+static void
+reset_debug_uses_in_loop (struct loop *loop, rtx reg, int debug_uses)
+{
+basic_block *body, bb;
+unsigned i;
+rtx insn;
+body = get_loop_body (loop);
+for (i = 0; debug_uses && i < loop->num_nodes; i++)
+{
+bb = body[i];
+FOR_BB_INSNS (bb, insn)
+	if (!DEBUG_INSN_P (insn) || !rtx_referenced_p (reg, insn))
+	  continue;
+	else
+	  {
+	    validate_change (insn, &INSN_VAR_LOCATION_LOC (insn),
+			     gen_rtx_UNKNOWN_VAR_LOC (), 0);
+	    if (!--debug_uses)
+	      break;
+	  }
+}
+free (body);
 }
 /* Determine whether INSN contains an accumulator
 which can be expanded into separate copies,
 one for each copy of the LOOP body.
 {
 rtx set, dest, src, op1, op2, something;
 struct var_to_expand *ves;
 enum machine_mode mode1, mode2;
 unsigned accum_pos;
+int debug_uses = 0;
 set = single_set (insn);
 if (!set)
 return NULL;
 /* The method of expansion that we are using; which includes
 the initialization of the expansions with zero and the summation of
 the expansions at the end of the computation will yield wrong results
 for (x = something - x) thus avoid using it in that case.  */
 if (accum_pos == 1
 && GET_CODE (src) == MINUS)
 return NULL;
-something = (accum_pos == 0)? op2 : op1;
+something = (accum_pos == 0) ? op2 : op1;
-if (!referenced_in_one_insn_in_loop_p (loop, dest))
+if (rtx_referenced_p (dest, something))
 return NULL;
-if (rtx_referenced_p (dest, something))
+if (!referenced_in_one_insn_in_loop_p (loop, dest, &debug_uses))
 return NULL;
 mode1 = GET_MODE (dest);
 mode2 = GET_MODE (something);
 if ((FLOAT_MODE_P (mode1)
 fprintf (dump_file,
 "\n;; Expanding Accumulator ");
 print_rtl (dump_file, dest);
 fprintf (dump_file, "\n");
 }
+if (debug_uses)
+/* Instead of resetting the debug insns, we could replace each
+debug use in the loop with the sum or product of all expanded
+accummulators.  Since we'll only know of all expansions at the
+end, we'd have to keep track of which vars_to_expand a debug
+insn in the loop references, take note of each copy of the
+debug insn during unrolling, and when it's all done, compute
+the sum or product of each variable and adjust the original
+debug insn and each copy thereof.  What a pain!  */
+reset_debug_uses_in_loop (loop, dest, debug_uses);
 /* Record the accumulator to expand.  */
 ves = XNEW (struct var_to_expand);
 ves->insn = insn;
 ves->reg = copy_rtx (dest);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/loop-unroll.c @ 63:b7f97abdc517 gcc-4.6-20100522