This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [patch] Handle equivalent loop invariants as one in loop-invariant.c
Hello,
here is the updated version of the patch.
Zdenek
Index: df.c
===================================================================
*** df.c (revision 108937)
--- df.c (working copy)
*************** df_bitmaps_alloc (struct df *df, bitmap
*** 451,464 ****
static void
df_bitmaps_free (struct df *df, int flags)
{
! basic_block bb;
! FOR_EACH_BB (bb)
{
! struct bb_info *bb_info = DF_BB_INFO (df, bb);
!
! if (!bb_info)
! continue;
if ((flags & DF_RD) && bb_info->rd_in)
{
--- 451,461 ----
static void
df_bitmaps_free (struct df *df, int flags)
{
! unsigned i;
! for (i = 0; i < df->n_bbs; i++)
{
! struct bb_info *bb_info = &df->bbs[i];
if ((flags & DF_RD) && bb_info->rd_in)
{
*************** static void
*** 2636,2642 ****
df_bb_modify (struct df *df, basic_block bb)
{
if ((unsigned) bb->index >= df->n_bbs)
! df_bb_table_realloc (df, df->n_bbs);
bitmap_set_bit (df->bbs_modified, bb->index);
}
--- 2633,2639 ----
df_bb_modify (struct df *df, basic_block bb)
{
if ((unsigned) bb->index >= df->n_bbs)
! df_bb_table_realloc (df, bb->index);
bitmap_set_bit (df->bbs_modified, bb->index);
}
*************** df_find_def (struct df *df, rtx insn, rt
*** 3032,3056 ****
{
struct df_link *defs;
for (defs = DF_INSN_DEFS (df, insn); defs; defs = defs->next)
! if (rtx_equal_p (DF_REF_REG (defs->ref), reg))
return defs->ref;
return NULL;
}
! /* Return 1 if REG is referenced in INSN, zero otherwise. */
! int
! df_reg_used (struct df *df, rtx insn, rtx reg)
{
struct df_link *uses;
for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
! if (rtx_equal_p (DF_REF_REG (uses->ref), reg))
! return 1;
! return 0;
}
static int
--- 3029,3070 ----
{
struct df_link *defs;
+ if (GET_CODE (reg) == SUBREG)
+ reg = SUBREG_REG (reg);
+ gcc_assert (REG_P (reg));
+
for (defs = DF_INSN_DEFS (df, insn); defs; defs = defs->next)
! if (rtx_equal_p (DF_REF_REAL_REG (defs->ref), reg))
return defs->ref;
return NULL;
}
! /* Finds the reference corresponding to the use of REG in INSN.
! DF is the dataflow object. */
! struct ref *
! df_find_use (struct df *df, rtx insn, rtx reg)
{
struct df_link *uses;
+ if (GET_CODE (reg) == SUBREG)
+ reg = SUBREG_REG (reg);
+ gcc_assert (REG_P (reg));
+
for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
! if (rtx_equal_p (DF_REF_REAL_REG (uses->ref), reg))
! return uses->ref;
! return NULL;
! }
!
! /* Return 1 if REG is referenced in INSN, zero otherwise. */
!
! int
! df_reg_used (struct df *df, rtx insn, rtx reg)
! {
! return df_find_use (df, insn, reg) != NULL;
}
static int
Index: df.h
===================================================================
*** df.h (revision 108937)
--- df.h (working copy)
*************** extern struct ref *df_bb_regno_last_def_
*** 290,295 ****
--- 290,297 ----
extern struct ref *df_find_def (struct df *, rtx, rtx);
+ extern struct ref *df_find_use (struct df *, rtx, rtx);
+
extern int df_reg_used (struct df *, rtx, rtx);
/* Functions for debugging from GDB. */
Index: loop-invariant.c
===================================================================
*** loop-invariant.c (revision 108937)
--- loop-invariant.c (working copy)
*************** Software Foundation, 51 Franklin Street,
*** 46,55 ****
--- 46,57 ----
#include "basic-block.h"
#include "cfgloop.h"
#include "expr.h"
+ #include "recog.h"
#include "output.h"
#include "function.h"
#include "flags.h"
#include "df.h"
+ #include "hashtab.h"
/* The data stored for the loop. */
*************** struct invariant
*** 88,95 ****
/* The number of the invariant. */
unsigned invno;
! /* Whether we already processed the invariant. */
! bool processed;
/* The definition of the invariant. */
struct def *def;
--- 90,101 ----
/* The number of the invariant. */
unsigned invno;
! /* The number of the invariant with the same value. */
! unsigned eqto;
!
! /* If we moved the invariant out of the loop, the register that contains its
! value. */
! rtx reg;
/* The definition of the invariant. */
struct def *def;
*************** struct invariant
*** 114,119 ****
--- 120,142 ----
unsigned stamp;
};
+ /* Entry for hash table of invariant expressions. */
+
+ struct invariant_expr_entry
+ {
+ /* The invariant. */
+ struct invariant *inv;
+
+ /* Its value. */
+ rtx expr;
+
+ /* Its mode. */
+ enum machine_mode mode;
+
+ /* Its hash. */
+ hashval_t hash;
+ };
+
/* The actual stamp for marking already visited invariants during determining
costs of movements. */
*************** check_maybe_invariant (rtx x)
*** 199,204 ****
--- 222,490 ----
return true;
}
+ /* Returns the invariant definition for USE, or NULL if USE is not
+ invariant. */
+
+ static struct invariant *
+ invariant_for_use (struct ref *use)
+ {
+ struct df_link *defs;
+ struct ref *def;
+ basic_block bb = BLOCK_FOR_INSN (use->insn), def_bb;
+
+ defs = DF_REF_CHAIN (use);
+ if (!defs || defs->next)
+ return NULL;
+ def = defs->ref;
+ if (!DF_REF_DATA (def))
+ return NULL;
+
+ def_bb = DF_REF_BB (def);
+ if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb))
+ return NULL;
+ return DF_REF_DATA (def);
+ }
+
+ /* Computes hash value for invariant expression X in INSN. */
+
+ static hashval_t
+ hash_invariant_expr_1 (rtx insn, rtx x)
+ {
+ enum rtx_code code = GET_CODE (x);
+ int i, j;
+ const char *fmt;
+ hashval_t val = code;
+ int do_not_record_p;
+ struct ref *use;
+ struct invariant *inv;
+
+ switch (code)
+ {
+ case CONST_INT:
+ case CONST_DOUBLE:
+ case SYMBOL_REF:
+ case CONST:
+ case LABEL_REF:
+ return hash_rtx (x, GET_MODE (x), &do_not_record_p, NULL, false);
+
+ case REG:
+ use = df_find_use (df, insn, x);
+ if (!use)
+ return hash_rtx (x, GET_MODE (x), &do_not_record_p, NULL, false);
+ inv = invariant_for_use (use);
+ if (!inv)
+ return hash_rtx (x, GET_MODE (x), &do_not_record_p, NULL, false);
+
+ gcc_assert (inv->eqto != ~0u);
+ return inv->eqto;
+
+ default:
+ break;
+ }
+
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+ {
+ if (fmt[i] == 'e')
+ val ^= hash_invariant_expr_1 (insn, XEXP (x, i));
+ else if (fmt[i] == 'E')
+ {
+ for (j = 0; j < XVECLEN (x, i); j++)
+ val ^= hash_invariant_expr_1 (insn, XVECEXP (x, i, j));
+ }
+ }
+
+ return val;
+ }
+
+ /* Returns true if the invariant expressions E1 and E2 used in insns INSN1
+ and INSN2 have always the same value. */
+
+ static bool
+ invariant_expr_equal_p (rtx insn1, rtx e1, rtx insn2, rtx e2)
+ {
+ enum rtx_code code = GET_CODE (e1);
+ int i, j;
+ const char *fmt;
+ struct ref *use1, *use2;
+ struct invariant *inv1 = NULL, *inv2 = NULL;
+ rtx sub1, sub2;
+
+ /* If mode of only one of the operands is VOIDmode, it is not equivalent to
+ the other one. If both are VOIDmode, we rely on the caller of this
+ function to verify that their modes are the same. */
+ if (code != GET_CODE (e2) || GET_MODE (e1) != GET_MODE (e2))
+ return false;
+
+ switch (code)
+ {
+ case CONST_INT:
+ case CONST_DOUBLE:
+ case SYMBOL_REF:
+ case CONST:
+ case LABEL_REF:
+ return rtx_equal_p (e1, e2);
+
+ case REG:
+ use1 = df_find_use (df, insn1, e1);
+ use2 = df_find_use (df, insn2, e2);
+ if (use1)
+ inv1 = invariant_for_use (use1);
+ if (use2)
+ inv2 = invariant_for_use (use2);
+
+ if (!inv1 && !inv2)
+ return rtx_equal_p (e1, e2);
+
+ if (!inv1 || !inv2)
+ return false;
+
+ gcc_assert (inv1->eqto != ~0u);
+ gcc_assert (inv2->eqto != ~0u);
+ return inv1->eqto == inv2->eqto;
+
+ default:
+ break;
+ }
+
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+ {
+ if (fmt[i] == 'e')
+ {
+ sub1 = XEXP (e1, i);
+ sub2 = XEXP (e2, i);
+
+ if (!invariant_expr_equal_p (insn1, sub1, insn2, sub2))
+ return false;
+ }
+
+ else if (fmt[i] == 'E')
+ {
+ if (XVECLEN (e1, i) != XVECLEN (e2, i))
+ return false;
+
+ for (j = 0; j < XVECLEN (e1, i); j++)
+ {
+ sub1 = XVECEXP (e1, i, j);
+ sub2 = XVECEXP (e2, i, j);
+
+ if (!invariant_expr_equal_p (insn1, sub1, insn2, sub2))
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ /* Returns hash value for invariant expression entry E. */
+
+ static hashval_t
+ hash_invariant_expr (const void *e)
+ {
+ const struct invariant_expr_entry *entry = e;
+
+ return entry->hash;
+ }
+
+ /* Compares invariant expression entries E1 and E2. */
+
+ static int
+ eq_invariant_expr (const void *e1, const void *e2)
+ {
+ const struct invariant_expr_entry *entry1 = e1;
+ const struct invariant_expr_entry *entry2 = e2;
+
+ if (entry1->mode != entry2->mode)
+ return 0;
+
+ return invariant_expr_equal_p (entry1->inv->insn, entry1->expr,
+ entry2->inv->insn, entry2->expr);
+ }
+
+ /* Checks whether invariant with value EXPR in machine mode MODE is
+ recorded in EQ. If this is the case, return the invariant. Otherwise
+ insert INV to the table for this expression and return INV. */
+
+ static struct invariant *
+ find_or_insert_inv (htab_t eq, rtx expr, enum machine_mode mode,
+ struct invariant *inv)
+ {
+ hashval_t hash = hash_invariant_expr_1 (inv->insn, expr);
+ struct invariant_expr_entry *entry;
+ struct invariant_expr_entry pentry;
+ PTR *slot;
+
+ pentry.expr = expr;
+ pentry.inv = inv;
+ pentry.mode = mode;
+ slot = htab_find_slot_with_hash (eq, &pentry, hash, INSERT);
+ entry = *slot;
+
+ if (entry)
+ return entry->inv;
+
+ entry = xmalloc (sizeof (struct invariant_expr_entry));
+ entry->inv = inv;
+ entry->expr = expr;
+ entry->mode = mode;
+ entry->hash = hash;
+ *slot = entry;
+
+ return inv;
+ }
+
+ /* Finds invariants identical to INV and records the equivalence. EQ is the
+ hash table of the invariants. */
+
+ static void
+ find_identical_invariants (htab_t eq, struct invariant *inv)
+ {
+ unsigned depno;
+ bitmap_iterator bi;
+ struct invariant *dep;
+ rtx expr, set;
+ enum machine_mode mode;
+
+ if (inv->eqto != ~0u)
+ return;
+
+ EXECUTE_IF_SET_IN_BITMAP (inv->depends_on, 0, depno, bi)
+ {
+ dep = VEC_index (invariant_p, invariants, depno);
+ find_identical_invariants (eq, dep);
+ }
+
+ set = single_set (inv->insn);
+ expr = SET_SRC (set);
+ mode = GET_MODE (expr);
+ if (mode == VOIDmode)
+ mode = GET_MODE (SET_DEST (set));
+ inv->eqto = find_or_insert_inv (eq, expr, mode, inv)->invno;
+
+ if (dump_file && inv->eqto != inv->invno)
+ fprintf (dump_file,
+ "Invariant %d is equivalent to invariant %d.\n ",
+ inv->invno, inv->eqto);
+ }
+
+ /* Find invariants with the same value and record the equivalences. */
+
+ static void
+ merge_identical_invariants (void)
+ {
+ unsigned i;
+ struct invariant *inv;
+ htab_t eq = htab_create (VEC_length (invariant_p, invariants),
+ hash_invariant_expr, eq_invariant_expr, free);
+
+ for (i = 0; VEC_iterate (invariant_p, invariants, i, inv); i++)
+ find_identical_invariants (eq, inv);
+
+ htab_delete (eq);
+ }
+
/* Determines the basic blocks inside LOOP that are always executed and
stores their bitmap to ALWAYS_REACHED. MAY_EXIT is a bitmap of
basic blocks that may either exit the loop, or contain the call that
*************** find_defs (struct loop *loop, basic_bloc
*** 320,328 ****
/* Creates a new invariant for definition DEF in INSN, depending on invariants
in DEPENDS_ON. ALWAYS_EXECUTED is true if the insn is always executed,
! unless the program ends due to a function call. */
! static void
create_new_invariant (struct def *def, rtx insn, bitmap depends_on,
bool always_executed)
{
--- 606,615 ----
/* Creates a new invariant for definition DEF in INSN, depending on invariants
in DEPENDS_ON. ALWAYS_EXECUTED is true if the insn is always executed,
! unless the program ends due to a function call. The newly created invariant
! is returned. */
! static struct invariant *
create_new_invariant (struct def *def, rtx insn, bitmap depends_on,
bool always_executed)
{
*************** create_new_invariant (struct def *def, r
*** 341,351 ****
inv->cost = rtx_cost (SET_SRC (set), SET);
inv->move = false;
! inv->processed = false;
inv->stamp = 0;
inv->insn = insn;
inv->invno = VEC_length (invariant_p, invariants);
if (def)
def->invno = inv->invno;
VEC_safe_push (invariant_p, heap, invariants, inv);
--- 628,639 ----
inv->cost = rtx_cost (SET_SRC (set), SET);
inv->move = false;
! inv->reg = NULL_RTX;
inv->stamp = 0;
inv->insn = insn;
inv->invno = VEC_length (invariant_p, invariants);
+ inv->eqto = ~0u;
if (def)
def->invno = inv->invno;
VEC_safe_push (invariant_p, heap, invariants, inv);
*************** create_new_invariant (struct def *def, r
*** 357,362 ****
--- 645,652 ----
INSN_UID (insn), inv->invno, inv->cost);
dump_bitmap (dump_file, inv->depends_on);
}
+
+ return inv;
}
/* Record USE at DEF. */
*************** check_dependencies (rtx insn, bitmap dep
*** 387,393 ****
struct ref *use, *def;
basic_block bb = BLOCK_FOR_INSN (insn), def_bb;
struct def *def_data;
!
for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
{
use = uses->ref;
--- 677,684 ----
struct ref *use, *def;
basic_block bb = BLOCK_FOR_INSN (insn), def_bb;
struct def *def_data;
! struct invariant *inv;
!
for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
{
use = uses->ref;
*************** check_dependencies (rtx insn, bitmap dep
*** 400,410 ****
return false;
def = defs->ref;
! def_data = DF_REF_DATA (def);
! if (!def_data)
return false;
def_bb = DF_REF_BB (def);
if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb))
return false;
--- 691,707 ----
return false;
def = defs->ref;
! inv = DF_REF_DATA (def);
! if (!inv)
return false;
+ def_data = inv->def;
+ gcc_assert (def_data != NULL);
+
def_bb = DF_REF_BB (def);
+ /* Note that in case bb == def_bb, we know that the definition dominates
+ insn, because def has DF_REF_DATA defined and we process the insns
+ in the basic block bb sequentially. */
if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb))
return false;
*************** find_invariant_insn (rtx insn, bool alwa
*** 426,438 ****
bitmap depends_on;
rtx set, dest;
bool simple = true;
/* Until we get rid of LIBCALLS. */
if (find_reg_note (insn, REG_RETVAL, NULL_RTX)
|| find_reg_note (insn, REG_LIBCALL, NULL_RTX)
|| find_reg_note (insn, REG_NO_CONFLICT, NULL_RTX))
return;
!
set = single_set (insn);
if (!set)
return;
--- 723,736 ----
bitmap depends_on;
rtx set, dest;
bool simple = true;
+ struct invariant *inv;
/* Until we get rid of LIBCALLS. */
if (find_reg_note (insn, REG_RETVAL, NULL_RTX)
|| find_reg_note (insn, REG_LIBCALL, NULL_RTX)
|| find_reg_note (insn, REG_NO_CONFLICT, NULL_RTX))
return;
!
set = single_set (insn);
if (!set)
return;
*************** find_invariant_insn (rtx insn, bool alwa
*** 465,479 ****
}
if (simple)
! {
! ref = df_find_def (df, insn, dest);
! def = xcalloc (1, sizeof (struct def));
! DF_REF_DATA (ref) = def;
! }
else
def = NULL;
! create_new_invariant (def, insn, depends_on, always_executed);
}
/* Record registers used in INSN that have a unique invariant definition. */
--- 763,779 ----
}
if (simple)
! def = xcalloc (1, sizeof (struct def));
else
def = NULL;
! inv = create_new_invariant (def, insn, depends_on, always_executed);
!
! if (simple)
! {
! ref = df_find_def (df, insn, dest);
! DF_REF_DATA (ref) = inv;
! }
}
/* Record registers used in INSN that have a unique invariant definition. */
*************** find_invariant_insn (rtx insn, bool alwa
*** 481,506 ****
static void
record_uses (rtx insn)
{
! struct df_link *uses, *defs;
! struct ref *use, *def;
! basic_block bb = BLOCK_FOR_INSN (insn), def_bb;
!
for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
{
use = uses->ref;
!
! defs = DF_REF_CHAIN (use);
! if (!defs || defs->next)
! continue;
! def = defs->ref;
! if (!DF_REF_DATA (def))
! continue;
!
! def_bb = DF_REF_BB (def);
! if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb))
! continue;
!
! record_use (DF_REF_DATA (def), DF_REF_LOC (use), DF_REF_INSN (use));
}
}
--- 781,796 ----
static void
record_uses (rtx insn)
{
! struct df_link *uses;
! struct ref *use;
! struct invariant *inv;
!
for (uses = DF_INSN_USES (df, insn); uses; uses = uses->next)
{
use = uses->ref;
! inv = invariant_for_use (use);
! if (inv)
! record_use (inv->def, DF_REF_LOC (use), DF_REF_INSN (use));
}
}
*************** find_invariants (struct loop *loop)
*** 573,578 ****
--- 863,869 ----
find_defs (loop, body);
find_invariants_body (loop, body, always_reached, always_executed);
+ merge_identical_invariants ();
BITMAP_FREE (always_reached);
BITMAP_FREE (always_executed);
*************** get_inv_cost (struct invariant *inv, int
*** 607,612 ****
--- 898,906 ----
struct invariant *dep;
bitmap_iterator bi;
+ /* Find the representative of the class of the equivalent invariants. */
+ inv = VEC_index (invariant_p, invariants, inv->eqto);
+
*comp_cost = 0;
*regs_needed = 0;
if (inv->move
*************** best_gain_for_invariant (struct invarian
*** 683,688 ****
--- 977,986 ----
if (inv->move)
continue;
+ /* Only consider the "representatives" of equivalent invariants. */
+ if (inv->eqto != inv->invno)
+ continue;
+
again = gain_for_invariant (inv, &aregs_needed,
new_regs, regs_used, n_inv_uses);
if (again > gain)
*************** set_move_mark (unsigned invno)
*** 704,709 ****
--- 1002,1010 ----
struct invariant *inv = VEC_index (invariant_p, invariants, invno);
bitmap_iterator bi;
+ /* Find the representative of the class of the equivalent invariants. */
+ inv = VEC_index (invariant_p, invariants, inv->eqto);
+
if (inv->move)
return;
inv->move = true;
*************** static void
*** 766,815 ****
move_invariant_reg (struct loop *loop, unsigned invno)
{
struct invariant *inv = VEC_index (invariant_p, invariants, invno);
unsigned i;
basic_block preheader = loop_preheader_edge (loop)->src;
rtx reg, set;
struct use *use;
bitmap_iterator bi;
! if (inv->processed)
return;
- inv->processed = true;
! if (inv->depends_on)
{
! EXECUTE_IF_SET_IN_BITMAP (inv->depends_on, 0, i, bi)
{
! move_invariant_reg (loop, i);
}
- }
! /* Move the set out of the loop. If the set is always executed (we could
! omit this condition if we know that the register is unused outside of the
! loop, but it does not seem worth finding out) and it has no uses that
! would not be dominated by it, we may just move it (TODO). Otherwise we
! need to create a temporary register. */
! set = single_set (inv->insn);
! reg = gen_reg_rtx (GET_MODE (SET_DEST (set)));
! df_pattern_emit_after (df, gen_move_insn (SET_DEST (set), reg),
! BLOCK_FOR_INSN (inv->insn), inv->insn);
!
! /* If the SET_DEST of the invariant insn is a reg, we can just move
! the insn out of the loop. Otherwise, we have to use gen_move_insn
! to let emit_move_insn produce a valid instruction stream. */
! if (REG_P (SET_DEST (set)))
! {
! SET_DEST (set) = reg;
! reorder_insns (inv->insn, inv->insn, BB_END (preheader));
! df_insn_modify (df, preheader, inv->insn);
}
else
{
! df_pattern_emit_after (df, gen_move_insn (reg, SET_SRC (set)),
! preheader, BB_END (preheader));
df_insn_delete (df, BLOCK_FOR_INSN (inv->insn), inv->insn);
}
/* Replace the uses we know to be dominated. It saves work for copy
propagation, and also it is necessary so that dependent invariants
are computed right. */
--- 1067,1134 ----
move_invariant_reg (struct loop *loop, unsigned invno)
{
struct invariant *inv = VEC_index (invariant_p, invariants, invno);
+ struct invariant *repr = VEC_index (invariant_p, invariants, inv->eqto);
unsigned i;
basic_block preheader = loop_preheader_edge (loop)->src;
rtx reg, set;
struct use *use;
bitmap_iterator bi;
! if (inv->reg
! || !repr->move)
return;
! /* If this is a representative of the class of equivalent invariants,
! really move the invariant. Otherwise just replace its use with
! the register used for the representative. */
! if (inv == repr)
{
! if (inv->depends_on)
{
! EXECUTE_IF_SET_IN_BITMAP (inv->depends_on, 0, i, bi)
! {
! move_invariant_reg (loop, i);
! }
}
! /* Move the set out of the loop. If the set is always executed (we could
! omit this condition if we know that the register is unused outside of the
! loop, but it does not seem worth finding out) and it has no uses that
! would not be dominated by it, we may just move it (TODO). Otherwise we
! need to create a temporary register. */
! set = single_set (inv->insn);
! reg = gen_reg_rtx (GET_MODE (SET_DEST (set)));
! df_pattern_emit_after (df, gen_move_insn (SET_DEST (set), reg),
! BLOCK_FOR_INSN (inv->insn), inv->insn);
!
! /* If the SET_DEST of the invariant insn is a reg, we can just move
! the insn out of the loop. Otherwise, we have to use gen_move_insn
! to let emit_move_insn produce a valid instruction stream. */
! if (REG_P (SET_DEST (set)))
! {
! SET_DEST (set) = reg;
! reorder_insns (inv->insn, inv->insn, BB_END (preheader));
! df_insn_modify (df, preheader, inv->insn);
! }
! else
! {
! df_pattern_emit_after (df, gen_move_insn (reg, SET_SRC (set)),
! preheader, BB_END (preheader));
! df_insn_delete (df, BLOCK_FOR_INSN (inv->insn), inv->insn);
! }
}
else
{
! move_invariant_reg (loop, repr->invno);
! reg = repr->reg;
! set = single_set (inv->insn);
! df_pattern_emit_after (df, gen_move_insn (SET_DEST (set), reg),
! BLOCK_FOR_INSN (inv->insn), inv->insn);
df_insn_delete (df, BLOCK_FOR_INSN (inv->insn), inv->insn);
}
+ inv->reg = reg;
+
/* Replace the uses we know to be dominated. It saves work for copy
propagation, and also it is necessary so that dependent invariants
are computed right. */
*************** move_invariants (struct loop *loop)
*** 833,842 ****
unsigned i;
for (i = 0; VEC_iterate (invariant_p, invariants, i, inv); i++)
! {
! if (inv->move)
! move_invariant_reg (loop, i);
! }
}
/* Initializes invariant motion data. */
--- 1152,1158 ----
unsigned i;
for (i = 0; VEC_iterate (invariant_p, invariants, i, inv); i++)
! move_invariant_reg (loop, i);
}
/* Initializes invariant motion data. */
*************** free_inv_motion_data (void)
*** 863,871 ****
if (!df->defs[i])
continue;
! def = DF_REF_DATA (df->defs[i]);
! if (!def)
continue;
free_use_list (def->uses);
free (def);
--- 1179,1189 ----
if (!df->defs[i])
continue;
! inv = DF_REF_DATA (df->defs[i]);
! if (!inv)
continue;
+ def = inv->def;
+ gcc_assert (def != NULL);
free_use_list (def->uses);
free (def);
Index: Makefile.in
===================================================================
*** Makefile.in (revision 108937)
--- Makefile.in (working copy)
*************** loop-iv.o : loop-iv.c $(CONFIG_H) $(SYST
*** 2372,2378 ****
output.h intl.h
loop-invariant.o : loop-invariant.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) \
$(BASIC_BLOCK_H) hard-reg-set.h $(CFGLOOP_H) $(EXPR_H) coretypes.h \
! $(TM_H) $(TM_P_H) function.h $(FLAGS_H) $(DF_H) $(OBSTACK_H) output.h
cfgloopmanip.o : cfgloopmanip.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) \
$(BASIC_BLOCK_H) hard-reg-set.h $(CFGLOOP_H) $(CFGLAYOUT_H) output.h \
coretypes.h $(TM_H) cfghooks.h $(OBSTACK_H)
--- 2372,2379 ----
output.h intl.h
loop-invariant.o : loop-invariant.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) \
$(BASIC_BLOCK_H) hard-reg-set.h $(CFGLOOP_H) $(EXPR_H) coretypes.h \
! $(TM_H) $(TM_P_H) function.h $(FLAGS_H) $(DF_H) $(OBSTACK_H) output.h \
! $(HASHTAB_H)
cfgloopmanip.o : cfgloopmanip.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) \
$(BASIC_BLOCK_H) hard-reg-set.h $(CFGLOOP_H) $(CFGLAYOUT_H) output.h \
coretypes.h $(TM_H) cfghooks.h $(OBSTACK_H)