CbC/CbC_gcc: gcc/gcse.c comparison

comparison gcc/gcse.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
 /* Global common subexpression elimination/Partial redundancy elimination
 and global constant/copy propagation for GNU compiler.
 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+2006, 2007, 2008, 2009, 2010 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 "tree.h"
 #include "tm_p.h"
 #include "regs.h"
 #include "hard-reg-set.h"
 #include "flags.h"
-#include "real.h"
 #include "insn-config.h"
 #include "recog.h"
 #include "basic-block.h"
 #include "output.h"
 #include "function.h"
 #include "hashtab.h"
 #include "df.h"
 #include "dbgcnt.h"
 #include "target.h"
-/* Propagate flow information through back edges and thus enable PRE's
-moving loop invariant calculations out of loops.
-Originally this tended to create worse overall code, but several
-improvements during the development of PRE seem to have made following
-back edges generally a win.
-Note much of the loop invariant code motion done here would normally
-be done by loop.c, which has more heuristics for when to move invariants
-out of loops.  At some point we might need to move some of those
-heuristics into gcse.c.  */
 /* We support GCSE via Partial Redundancy Elimination.  PRE optimizations
-are a superset of those done by GCSE.
+are a superset of those done by classic GCSE.
 We perform the following steps:
 1) Compute table of places where registers are set.
 for size, or code hoisting if we are.
 4) Perform another pass of copy/constant propagation.  Try to bypass
 conditional jumps if the condition can be computed from a value of
 an incoming edge.
-5) Perform store motion.
 Two passes of copy/constant propagation are done because the first one
 enables more GCSE and the second one helps to clean up the copies that
 GCSE creates.  This is needed more for PRE than for Classic because Classic
 GCSE will try to use an existing register containing the common
 Expressions we are interested in GCSE-ing are of the form
 (set (pseudo-reg) (expression)).
 Function want_to_gcse_p says what these are.
-In addition, expressions in REG_EQUAL notes are candidates for GXSE-ing.
+In addition, expressions in REG_EQUAL notes are candidates for GCSE-ing.
 This allows PRE to hoist expressions that are expressed in multiple insns,
-such as comprex address calculations (e.g. for PIC code, or loads with a
+such as complex address calculations (e.g. for PIC code, or loads with a
-high part and as lowe part).
+high part and a low part).
 PRE handles moving invariant expressions out of loops (by treating them as
 partially redundant).
-Eventually it would be nice to replace cse.c/gcse.c with SSA (static single
-assignment) based GVN (global value numbering).  L. T. Simpson's paper
-(Rice University) on value numbering is a useful reference for this.
 **********************
 We used to support multiple passes but there are diminishing returns in
 doing so.  The first pass usually makes 90% of the changes that are doable.
 Various papers have argued that PRE DFA is expensive (O(n^2)) and others
 argue it is not.  The number of iterations for the algorithm to converge
 is typically 2-4 so I don't view it as that expensive (relatively speaking).
-PRE GCSE depends heavily on the second CSE pass to clean up the copies
+PRE GCSE depends heavily on the second CPROP pass to clean up the copies
 we create.  To make an expression reach the place where it's redundant,
 the result of the expression is copied to a new register, and the redundant
 expression is deleted by replacing it with this new register.  Classic GCSE
 doesn't have this problem as much as it computes the reaching defs of
 each register in each block and thus can try to use an existing
 static void
 alloc_gcse_mem (void)
 {
 /* Allocate vars to track sets of regs.  */
-reg_set_bitmap = BITMAP_ALLOC (NULL);
+reg_set_bitmap = ALLOC_REG_SET (NULL);
 /* Allocate array to keep a list of insns which modify memory in each
 basic block.  */
 modify_mem_list = GCNEWVEC (rtx, last_basic_block);
 canon_modify_mem_list = GCNEWVEC (rtx, last_basic_block);
 	  /* The occurrences recorded in antic_occr are exactly those that
 	     we want to set to nonzero in ANTLOC.  */
 	  if (antloc)
 	    for (occr = expr->antic_occr; occr != NULL; occr = occr->next)
 	      {
-		SET_BIT (antloc[BLOCK_NUM (occr->insn)], indx);
+		SET_BIT (antloc[BLOCK_FOR_INSN (occr->insn)->index], indx);
 		/* While we're scanning the table, this is a good place to
 		   initialize this.  */
 		occr->deleted_p = 0;
 	      }
 	  /* The occurrences recorded in avail_occr are exactly those that
 	     we want to set to nonzero in COMP.  */
 	  if (comp)
 	    for (occr = expr->avail_occr; occr != NULL; occr = occr->next)
 	      {
-		SET_BIT (comp[BLOCK_NUM (occr->insn)], indx);
+		SET_BIT (comp[BLOCK_FOR_INSN (occr->insn)->index], indx);
 		/* While we're scanning the table, this is a good place to
 		   initialize this.  */
 		occr->copied_p = 0;
 	      }
 /* Now record the occurrence(s).  */
 if (antic_p)
 {
 antic_occr = cur_expr->antic_occr;
-if (antic_occr && BLOCK_NUM (antic_occr->insn) != BLOCK_NUM (insn))
+if (antic_occr
+	  && BLOCK_FOR_INSN (antic_occr->insn) != BLOCK_FOR_INSN (insn))
 	antic_occr = NULL;
 if (antic_occr)
 	/* Found another instance of the expression in the same basic block.
 	   Prefer the currently recorded one.  We want the first one in the
 if (avail_p)
 {
 avail_occr = cur_expr->avail_occr;
-if (avail_occr && BLOCK_NUM (avail_occr->insn) == BLOCK_NUM (insn))
+if (avail_occr
+	  && BLOCK_FOR_INSN (avail_occr->insn) == BLOCK_FOR_INSN (insn))
 	{
 	  /* Found another instance of the expression in the same basic block.
 	     Prefer this occurrence to the currently recorded one.  We want
 	     the last one in the block and the block is scanned from start
 	     to end.  */
 }
 /* Now record the occurrence.  */
 cur_occr = cur_expr->avail_occr;
-if (cur_occr && BLOCK_NUM (cur_occr->insn) == BLOCK_NUM (insn))
+if (cur_occr
+&& BLOCK_FOR_INSN (cur_occr->insn) == BLOCK_FOR_INSN (insn))
 {
 /* Found another instance of the expression in the same basic block.
 	 Prefer this occurrence to the currently recorded one.  We want
 	 the last one in the block and the block is scanned from start
 	 to end.  */
 return;
 dest_addr = get_addr (XEXP (dest, 0));
 dest_addr = canon_rtx (dest_addr);
 insn = (rtx) v_insn;
-bb = BLOCK_NUM (insn);
+bb = BLOCK_FOR_INSN (insn)->index;
 canon_modify_mem_list[bb] =
 alloc_EXPR_LIST (VOIDmode, dest_addr, canon_modify_mem_list[bb]);
 canon_modify_mem_list[bb] =
 alloc_EXPR_LIST (VOIDmode, dest, canon_modify_mem_list[bb]);
 a CALL_INSN).  We merely need to record which insns modify memory.  */
 static void
 record_last_mem_set_info (rtx insn)
 {
-int bb = BLOCK_NUM (insn);
+int bb = BLOCK_FOR_INSN (insn)->index;
 /* load_killed_in_block_p will handle the case of calls clobbering
 everything.  */
 modify_mem_list[bb] = alloc_INSN_LIST (insn, modify_mem_list[bb]);
 bitmap_set_bit (modify_mem_list_set, bb);
 /* Find a set that is available at the start of the block
 	 which contains INSN.  */
 while (set)
 	{
-	  if (TEST_BIT (cprop_avin[BLOCK_NUM (insn)], set->bitmap_index))
+	  if (TEST_BIT (cprop_avin[BLOCK_FOR_INSN (insn)->index],
+			set->bitmap_index))
 	    break;
 	  set = next_set (regno, set);
 	}
 /* If no available set was found we've reached the end of the
 basic_block bb;
 rtx insn;
 struct reg_use *reg_used;
 bool changed = false;
-cselib_init (false);
+cselib_init (0);
 FOR_EACH_BB (bb)
 {
 FOR_BB_INSNS (bb, insn)
 	{
 	  if (INSN_P (insn))
 of exception handling.  */
 else if (CALL_P (insn)
 	   && (!single_succ_p (bb)
 	       || single_succ_edge (bb)->flags & EDGE_ABNORMAL))
 {
-/* Keeping in mind SMALL_REGISTER_CLASSES and parameters in registers,
+/* Keeping in mind targets with small register classes and parameters
-	 we search backward and place the instructions before the first
+in registers, we search backward and place the instructions before
-	 parameter is loaded.  Do this for everyone for consistency and a
+	 the first parameter is loaded.  Do this for everyone for consistency
-	 presumption that we'll get better code elsewhere as well.
+	 and a presumption that we'll get better code elsewhere as well.
 	 It should always be the case that we can put these instructions
 	 anywhere in the basic block with performing PRE optimizations.
 	 Check this.  */
 gcse_create_count++;
 if (dump_file)
 fprintf (dump_file,
 	     "PRE: bb %d, insn %d, copy expression %d in insn %d to reg %d\n",
-	      BLOCK_NUM (insn), INSN_UID (new_insn), indx,
+	      BLOCK_FOR_INSN (insn)->index, INSN_UID (new_insn), indx,
 	      INSN_UID (insn), regno);
 }
 /* Copy available expressions that reach the redundant expression
 to `reaching_reg'.  */
 static unsigned int
 execute_rtl_cprop (void)
 {
 delete_unreachable_blocks ();
-df_note_add_problem ();
 df_set_flags (DF_LR_RUN_DCE);
 df_analyze ();
 flag_rerun_cse_after_global_opts |= one_cprop_pass ();
 return 0;
 }
 static unsigned int
 execute_rtl_pre (void)
 {
 delete_unreachable_blocks ();
-df_note_add_problem ();
 df_analyze ();
 flag_rerun_cse_after_global_opts |= one_pre_gcse_pass ();
 return 0;
 }
 static unsigned int
 execute_rtl_hoist (void)
 {
 delete_unreachable_blocks ();
-df_note_add_problem ();
 df_analyze ();
 flag_rerun_cse_after_global_opts |= one_code_hoisting_pass ();
 return 0;
 }

Mercurial > hg > CbC > CbC_gcc

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