/* Global constant/copy propagation for RTL.
|
/* Global constant/copy propagation for RTL.
|
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
|
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
|
2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
|
2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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 terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "diagnostic-core.h"
|
#include "diagnostic-core.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
|
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "function.h"
|
#include "function.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "except.h"
|
#include "except.h"
|
#include "params.h"
|
#include "params.h"
|
#include "cselib.h"
|
#include "cselib.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "obstack.h"
|
#include "obstack.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "df.h"
|
#include "df.h"
|
#include "dbgcnt.h"
|
#include "dbgcnt.h"
|
#include "target.h"
|
#include "target.h"
|
|
|
|
|
/* An obstack for our working variables. */
|
/* An obstack for our working variables. */
|
static struct obstack cprop_obstack;
|
static struct obstack cprop_obstack;
|
|
|
/* Occurrence of an expression.
|
/* Occurrence of an expression.
|
There is one per basic block. If a pattern appears more than once the
|
There is one per basic block. If a pattern appears more than once the
|
last appearance is used. */
|
last appearance is used. */
|
|
|
struct occr
|
struct occr
|
{
|
{
|
/* Next occurrence of this expression. */
|
/* Next occurrence of this expression. */
|
struct occr *next;
|
struct occr *next;
|
/* The insn that computes the expression. */
|
/* The insn that computes the expression. */
|
rtx insn;
|
rtx insn;
|
};
|
};
|
|
|
typedef struct occr *occr_t;
|
typedef struct occr *occr_t;
|
DEF_VEC_P (occr_t);
|
DEF_VEC_P (occr_t);
|
DEF_VEC_ALLOC_P (occr_t, heap);
|
DEF_VEC_ALLOC_P (occr_t, heap);
|
|
|
/* Hash table entry for assignment expressions. */
|
/* Hash table entry for assignment expressions. */
|
|
|
struct expr
|
struct expr
|
{
|
{
|
/* The expression (DEST := SRC). */
|
/* The expression (DEST := SRC). */
|
rtx dest;
|
rtx dest;
|
rtx src;
|
rtx src;
|
|
|
/* Index in the available expression bitmaps. */
|
/* Index in the available expression bitmaps. */
|
int bitmap_index;
|
int bitmap_index;
|
/* Next entry with the same hash. */
|
/* Next entry with the same hash. */
|
struct expr *next_same_hash;
|
struct expr *next_same_hash;
|
/* List of available occurrence in basic blocks in the function.
|
/* List of available occurrence in basic blocks in the function.
|
An "available occurrence" is one that is the last occurrence in the
|
An "available occurrence" is one that is the last occurrence in the
|
basic block and whose operands are not modified by following statements
|
basic block and whose operands are not modified by following statements
|
in the basic block [including this insn]. */
|
in the basic block [including this insn]. */
|
struct occr *avail_occr;
|
struct occr *avail_occr;
|
};
|
};
|
|
|
/* Hash table for copy propagation expressions.
|
/* Hash table for copy propagation expressions.
|
Each hash table is an array of buckets.
|
Each hash table is an array of buckets.
|
??? It is known that if it were an array of entries, structure elements
|
??? It is known that if it were an array of entries, structure elements
|
`next_same_hash' and `bitmap_index' wouldn't be necessary. However, it is
|
`next_same_hash' and `bitmap_index' wouldn't be necessary. However, it is
|
not clear whether in the final analysis a sufficient amount of memory would
|
not clear whether in the final analysis a sufficient amount of memory would
|
be saved as the size of the available expression bitmaps would be larger
|
be saved as the size of the available expression bitmaps would be larger
|
[one could build a mapping table without holes afterwards though].
|
[one could build a mapping table without holes afterwards though].
|
Someday I'll perform the computation and figure it out. */
|
Someday I'll perform the computation and figure it out. */
|
|
|
struct hash_table_d
|
struct hash_table_d
|
{
|
{
|
/* The table itself.
|
/* The table itself.
|
This is an array of `set_hash_table_size' elements. */
|
This is an array of `set_hash_table_size' elements. */
|
struct expr **table;
|
struct expr **table;
|
|
|
/* Size of the hash table, in elements. */
|
/* Size of the hash table, in elements. */
|
unsigned int size;
|
unsigned int size;
|
|
|
/* Number of hash table elements. */
|
/* Number of hash table elements. */
|
unsigned int n_elems;
|
unsigned int n_elems;
|
};
|
};
|
|
|
/* Copy propagation hash table. */
|
/* Copy propagation hash table. */
|
static struct hash_table_d set_hash_table;
|
static struct hash_table_d set_hash_table;
|
|
|
/* Array of implicit set patterns indexed by basic block index. */
|
/* Array of implicit set patterns indexed by basic block index. */
|
static rtx *implicit_sets;
|
static rtx *implicit_sets;
|
|
|
/* Array of indexes of expressions for implicit set patterns indexed by basic
|
/* Array of indexes of expressions for implicit set patterns indexed by basic
|
block index. In other words, implicit_set_indexes[i] is the bitmap_index
|
block index. In other words, implicit_set_indexes[i] is the bitmap_index
|
of the expression whose RTX is implicit_sets[i]. */
|
of the expression whose RTX is implicit_sets[i]. */
|
static int *implicit_set_indexes;
|
static int *implicit_set_indexes;
|
|
|
/* Bitmap containing one bit for each register in the program.
|
/* Bitmap containing one bit for each register in the program.
|
Used when performing GCSE to track which registers have been set since
|
Used when performing GCSE to track which registers have been set since
|
the start or end of the basic block while traversing that block. */
|
the start or end of the basic block while traversing that block. */
|
static regset reg_set_bitmap;
|
static regset reg_set_bitmap;
|
|
|
/* Various variables for statistics gathering. */
|
/* Various variables for statistics gathering. */
|
|
|
/* Memory used in a pass.
|
/* Memory used in a pass.
|
This isn't intended to be absolutely precise. Its intent is only
|
This isn't intended to be absolutely precise. Its intent is only
|
to keep an eye on memory usage. */
|
to keep an eye on memory usage. */
|
static int bytes_used;
|
static int bytes_used;
|
|
|
/* Number of local constants propagated. */
|
/* Number of local constants propagated. */
|
static int local_const_prop_count;
|
static int local_const_prop_count;
|
/* Number of local copies propagated. */
|
/* Number of local copies propagated. */
|
static int local_copy_prop_count;
|
static int local_copy_prop_count;
|
/* Number of global constants propagated. */
|
/* Number of global constants propagated. */
|
static int global_const_prop_count;
|
static int global_const_prop_count;
|
/* Number of global copies propagated. */
|
/* Number of global copies propagated. */
|
static int global_copy_prop_count;
|
static int global_copy_prop_count;
|
|
|
#define GOBNEW(T) ((T *) cprop_alloc (sizeof (T)))
|
#define GOBNEW(T) ((T *) cprop_alloc (sizeof (T)))
|
#define GOBNEWVAR(T, S) ((T *) cprop_alloc ((S)))
|
#define GOBNEWVAR(T, S) ((T *) cprop_alloc ((S)))
|
|
|
/* Cover function to obstack_alloc. */
|
/* Cover function to obstack_alloc. */
|
|
|
static void *
|
static void *
|
cprop_alloc (unsigned long size)
|
cprop_alloc (unsigned long size)
|
{
|
{
|
bytes_used += size;
|
bytes_used += size;
|
return obstack_alloc (&cprop_obstack, size);
|
return obstack_alloc (&cprop_obstack, size);
|
}
|
}
|
|
|
/* Return nonzero if register X is unchanged from INSN to the end
|
/* Return nonzero if register X is unchanged from INSN to the end
|
of INSN's basic block. */
|
of INSN's basic block. */
|
|
|
static int
|
static int
|
reg_available_p (const_rtx x, const_rtx insn ATTRIBUTE_UNUSED)
|
reg_available_p (const_rtx x, const_rtx insn ATTRIBUTE_UNUSED)
|
{
|
{
|
return ! REGNO_REG_SET_P (reg_set_bitmap, REGNO (x));
|
return ! REGNO_REG_SET_P (reg_set_bitmap, REGNO (x));
|
}
|
}
|
|
|
/* Hash a set of register REGNO.
|
/* Hash a set of register REGNO.
|
|
|
Sets are hashed on the register that is set. This simplifies the PRE copy
|
Sets are hashed on the register that is set. This simplifies the PRE copy
|
propagation code.
|
propagation code.
|
|
|
??? May need to make things more elaborate. Later, as necessary. */
|
??? May need to make things more elaborate. Later, as necessary. */
|
|
|
static unsigned int
|
static unsigned int
|
hash_set (int regno, int hash_table_size)
|
hash_set (int regno, int hash_table_size)
|
{
|
{
|
unsigned int hash;
|
unsigned int hash;
|
|
|
hash = regno;
|
hash = regno;
|
return hash % hash_table_size;
|
return hash % hash_table_size;
|
}
|
}
|
|
|
/* Insert assignment DEST:=SET from INSN in the hash table.
|
/* Insert assignment DEST:=SET from INSN in the hash table.
|
DEST is a register and SET is a register or a suitable constant.
|
DEST is a register and SET is a register or a suitable constant.
|
If the assignment is already present in the table, record it as
|
If the assignment is already present in the table, record it as
|
the last occurrence in INSN's basic block.
|
the last occurrence in INSN's basic block.
|
IMPLICIT is true if it's an implicit set, false otherwise. */
|
IMPLICIT is true if it's an implicit set, false otherwise. */
|
|
|
static void
|
static void
|
insert_set_in_table (rtx dest, rtx src, rtx insn, struct hash_table_d *table,
|
insert_set_in_table (rtx dest, rtx src, rtx insn, struct hash_table_d *table,
|
bool implicit)
|
bool implicit)
|
{
|
{
|
bool found = false;
|
bool found = false;
|
unsigned int hash;
|
unsigned int hash;
|
struct expr *cur_expr, *last_expr = NULL;
|
struct expr *cur_expr, *last_expr = NULL;
|
struct occr *cur_occr;
|
struct occr *cur_occr;
|
|
|
hash = hash_set (REGNO (dest), table->size);
|
hash = hash_set (REGNO (dest), table->size);
|
|
|
for (cur_expr = table->table[hash]; cur_expr;
|
for (cur_expr = table->table[hash]; cur_expr;
|
cur_expr = cur_expr->next_same_hash)
|
cur_expr = cur_expr->next_same_hash)
|
{
|
{
|
if (dest == cur_expr->dest
|
if (dest == cur_expr->dest
|
&& src == cur_expr->src)
|
&& src == cur_expr->src)
|
{
|
{
|
found = true;
|
found = true;
|
break;
|
break;
|
}
|
}
|
last_expr = cur_expr;
|
last_expr = cur_expr;
|
}
|
}
|
|
|
if (! found)
|
if (! found)
|
{
|
{
|
cur_expr = GOBNEW (struct expr);
|
cur_expr = GOBNEW (struct expr);
|
bytes_used += sizeof (struct expr);
|
bytes_used += sizeof (struct expr);
|
if (table->table[hash] == NULL)
|
if (table->table[hash] == NULL)
|
/* This is the first pattern that hashed to this index. */
|
/* This is the first pattern that hashed to this index. */
|
table->table[hash] = cur_expr;
|
table->table[hash] = cur_expr;
|
else
|
else
|
/* Add EXPR to end of this hash chain. */
|
/* Add EXPR to end of this hash chain. */
|
last_expr->next_same_hash = cur_expr;
|
last_expr->next_same_hash = cur_expr;
|
|
|
/* Set the fields of the expr element.
|
/* Set the fields of the expr element.
|
We must copy X because it can be modified when copy propagation is
|
We must copy X because it can be modified when copy propagation is
|
performed on its operands. */
|
performed on its operands. */
|
cur_expr->dest = copy_rtx (dest);
|
cur_expr->dest = copy_rtx (dest);
|
cur_expr->src = copy_rtx (src);
|
cur_expr->src = copy_rtx (src);
|
cur_expr->bitmap_index = table->n_elems++;
|
cur_expr->bitmap_index = table->n_elems++;
|
cur_expr->next_same_hash = NULL;
|
cur_expr->next_same_hash = NULL;
|
cur_expr->avail_occr = NULL;
|
cur_expr->avail_occr = NULL;
|
}
|
}
|
|
|
/* Now record the occurrence. */
|
/* Now record the occurrence. */
|
cur_occr = cur_expr->avail_occr;
|
cur_occr = cur_expr->avail_occr;
|
|
|
if (cur_occr
|
if (cur_occr
|
&& BLOCK_FOR_INSN (cur_occr->insn) == BLOCK_FOR_INSN (insn))
|
&& BLOCK_FOR_INSN (cur_occr->insn) == BLOCK_FOR_INSN (insn))
|
{
|
{
|
/* Found another instance of the expression in the same basic block.
|
/* Found another instance of the expression in the same basic block.
|
Prefer this occurrence to the currently recorded one. We want
|
Prefer this occurrence to the currently recorded one. We want
|
the last one in the block and the block is scanned from start
|
the last one in the block and the block is scanned from start
|
to end. */
|
to end. */
|
cur_occr->insn = insn;
|
cur_occr->insn = insn;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* First occurrence of this expression in this basic block. */
|
/* First occurrence of this expression in this basic block. */
|
cur_occr = GOBNEW (struct occr);
|
cur_occr = GOBNEW (struct occr);
|
bytes_used += sizeof (struct occr);
|
bytes_used += sizeof (struct occr);
|
cur_occr->insn = insn;
|
cur_occr->insn = insn;
|
cur_occr->next = cur_expr->avail_occr;
|
cur_occr->next = cur_expr->avail_occr;
|
cur_expr->avail_occr = cur_occr;
|
cur_expr->avail_occr = cur_occr;
|
}
|
}
|
|
|
/* Record bitmap_index of the implicit set in implicit_set_indexes. */
|
/* Record bitmap_index of the implicit set in implicit_set_indexes. */
|
if (implicit)
|
if (implicit)
|
implicit_set_indexes[BLOCK_FOR_INSN(insn)->index] = cur_expr->bitmap_index;
|
implicit_set_indexes[BLOCK_FOR_INSN(insn)->index] = cur_expr->bitmap_index;
|
}
|
}
|
|
|
/* Determine whether the rtx X should be treated as a constant for CPROP.
|
/* Determine whether the rtx X should be treated as a constant for CPROP.
|
Since X might be inserted more than once we have to take care that it
|
Since X might be inserted more than once we have to take care that it
|
is sharable. */
|
is sharable. */
|
|
|
static bool
|
static bool
|
cprop_constant_p (const_rtx x)
|
cprop_constant_p (const_rtx x)
|
{
|
{
|
return CONSTANT_P (x) && (GET_CODE (x) != CONST || shared_const_p (x));
|
return CONSTANT_P (x) && (GET_CODE (x) != CONST || shared_const_p (x));
|
}
|
}
|
|
|
/* Scan SET present in INSN and add an entry to the hash TABLE.
|
/* Scan SET present in INSN and add an entry to the hash TABLE.
|
IMPLICIT is true if it's an implicit set, false otherwise. */
|
IMPLICIT is true if it's an implicit set, false otherwise. */
|
|
|
static void
|
static void
|
hash_scan_set (rtx set, rtx insn, struct hash_table_d *table, bool implicit)
|
hash_scan_set (rtx set, rtx insn, struct hash_table_d *table, bool implicit)
|
{
|
{
|
rtx src = SET_SRC (set);
|
rtx src = SET_SRC (set);
|
rtx dest = SET_DEST (set);
|
rtx dest = SET_DEST (set);
|
|
|
if (REG_P (dest)
|
if (REG_P (dest)
|
&& ! HARD_REGISTER_P (dest)
|
&& ! HARD_REGISTER_P (dest)
|
&& reg_available_p (dest, insn)
|
&& reg_available_p (dest, insn)
|
&& can_copy_p (GET_MODE (dest)))
|
&& can_copy_p (GET_MODE (dest)))
|
{
|
{
|
/* See if a REG_EQUAL note shows this equivalent to a simpler expression.
|
/* See if a REG_EQUAL note shows this equivalent to a simpler expression.
|
|
|
This allows us to do a single CPROP pass and still eliminate
|
This allows us to do a single CPROP pass and still eliminate
|
redundant constants, addresses or other expressions that are
|
redundant constants, addresses or other expressions that are
|
constructed with multiple instructions.
|
constructed with multiple instructions.
|
|
|
However, keep the original SRC if INSN is a simple reg-reg move. In
|
However, keep the original SRC if INSN is a simple reg-reg move. In
|
In this case, there will almost always be a REG_EQUAL note on the
|
In this case, there will almost always be a REG_EQUAL note on the
|
insn that sets SRC. By recording the REG_EQUAL value here as SRC
|
insn that sets SRC. By recording the REG_EQUAL value here as SRC
|
for INSN, we miss copy propagation opportunities.
|
for INSN, we miss copy propagation opportunities.
|
|
|
Note that this does not impede profitable constant propagations. We
|
Note that this does not impede profitable constant propagations. We
|
"look through" reg-reg sets in lookup_set. */
|
"look through" reg-reg sets in lookup_set. */
|
rtx note = find_reg_equal_equiv_note (insn);
|
rtx note = find_reg_equal_equiv_note (insn);
|
if (note != 0
|
if (note != 0
|
&& REG_NOTE_KIND (note) == REG_EQUAL
|
&& REG_NOTE_KIND (note) == REG_EQUAL
|
&& !REG_P (src)
|
&& !REG_P (src)
|
&& cprop_constant_p (XEXP (note, 0)))
|
&& cprop_constant_p (XEXP (note, 0)))
|
src = XEXP (note, 0), set = gen_rtx_SET (VOIDmode, dest, src);
|
src = XEXP (note, 0), set = gen_rtx_SET (VOIDmode, dest, src);
|
|
|
/* Record sets for constant/copy propagation. */
|
/* Record sets for constant/copy propagation. */
|
if ((REG_P (src)
|
if ((REG_P (src)
|
&& src != dest
|
&& src != dest
|
&& ! HARD_REGISTER_P (src)
|
&& ! HARD_REGISTER_P (src)
|
&& reg_available_p (src, insn))
|
&& reg_available_p (src, insn))
|
|| cprop_constant_p (src))
|
|| cprop_constant_p (src))
|
insert_set_in_table (dest, src, insn, table, implicit);
|
insert_set_in_table (dest, src, insn, table, implicit);
|
}
|
}
|
}
|
}
|
|
|
/* Process INSN and add hash table entries as appropriate. */
|
/* Process INSN and add hash table entries as appropriate. */
|
|
|
static void
|
static void
|
hash_scan_insn (rtx insn, struct hash_table_d *table)
|
hash_scan_insn (rtx insn, struct hash_table_d *table)
|
{
|
{
|
rtx pat = PATTERN (insn);
|
rtx pat = PATTERN (insn);
|
int i;
|
int i;
|
|
|
/* Pick out the sets of INSN and for other forms of instructions record
|
/* Pick out the sets of INSN and for other forms of instructions record
|
what's been modified. */
|
what's been modified. */
|
|
|
if (GET_CODE (pat) == SET)
|
if (GET_CODE (pat) == SET)
|
hash_scan_set (pat, insn, table, false);
|
hash_scan_set (pat, insn, table, false);
|
else if (GET_CODE (pat) == PARALLEL)
|
else if (GET_CODE (pat) == PARALLEL)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
{
|
{
|
rtx x = XVECEXP (pat, 0, i);
|
rtx x = XVECEXP (pat, 0, i);
|
|
|
if (GET_CODE (x) == SET)
|
if (GET_CODE (x) == SET)
|
hash_scan_set (x, insn, table, false);
|
hash_scan_set (x, insn, table, false);
|
}
|
}
|
}
|
}
|
|
|
/* Dump the hash table TABLE to file FILE under the name NAME. */
|
/* Dump the hash table TABLE to file FILE under the name NAME. */
|
|
|
static void
|
static void
|
dump_hash_table (FILE *file, const char *name, struct hash_table_d *table)
|
dump_hash_table (FILE *file, const char *name, struct hash_table_d *table)
|
{
|
{
|
int i;
|
int i;
|
/* Flattened out table, so it's printed in proper order. */
|
/* Flattened out table, so it's printed in proper order. */
|
struct expr **flat_table;
|
struct expr **flat_table;
|
unsigned int *hash_val;
|
unsigned int *hash_val;
|
struct expr *expr;
|
struct expr *expr;
|
|
|
flat_table = XCNEWVEC (struct expr *, table->n_elems);
|
flat_table = XCNEWVEC (struct expr *, table->n_elems);
|
hash_val = XNEWVEC (unsigned int, table->n_elems);
|
hash_val = XNEWVEC (unsigned int, table->n_elems);
|
|
|
for (i = 0; i < (int) table->size; i++)
|
for (i = 0; i < (int) table->size; i++)
|
for (expr = table->table[i]; expr != NULL; expr = expr->next_same_hash)
|
for (expr = table->table[i]; expr != NULL; expr = expr->next_same_hash)
|
{
|
{
|
flat_table[expr->bitmap_index] = expr;
|
flat_table[expr->bitmap_index] = expr;
|
hash_val[expr->bitmap_index] = i;
|
hash_val[expr->bitmap_index] = i;
|
}
|
}
|
|
|
fprintf (file, "%s hash table (%d buckets, %d entries)\n",
|
fprintf (file, "%s hash table (%d buckets, %d entries)\n",
|
name, table->size, table->n_elems);
|
name, table->size, table->n_elems);
|
|
|
for (i = 0; i < (int) table->n_elems; i++)
|
for (i = 0; i < (int) table->n_elems; i++)
|
if (flat_table[i] != 0)
|
if (flat_table[i] != 0)
|
{
|
{
|
expr = flat_table[i];
|
expr = flat_table[i];
|
fprintf (file, "Index %d (hash value %d)\n ",
|
fprintf (file, "Index %d (hash value %d)\n ",
|
expr->bitmap_index, hash_val[i]);
|
expr->bitmap_index, hash_val[i]);
|
print_rtl (file, expr->dest);
|
print_rtl (file, expr->dest);
|
fprintf (file, " := ");
|
fprintf (file, " := ");
|
print_rtl (file, expr->src);
|
print_rtl (file, expr->src);
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
|
|
free (flat_table);
|
free (flat_table);
|
free (hash_val);
|
free (hash_val);
|
}
|
}
|
|
|
/* Record as unavailable all registers that are DEF operands of INSN. */
|
/* Record as unavailable all registers that are DEF operands of INSN. */
|
|
|
static void
|
static void
|
make_set_regs_unavailable (rtx insn)
|
make_set_regs_unavailable (rtx insn)
|
{
|
{
|
struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
|
struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
|
df_ref *def_rec;
|
df_ref *def_rec;
|
|
|
for (def_rec = DF_INSN_INFO_DEFS (insn_info); *def_rec; def_rec++)
|
for (def_rec = DF_INSN_INFO_DEFS (insn_info); *def_rec; def_rec++)
|
SET_REGNO_REG_SET (reg_set_bitmap, DF_REF_REGNO (*def_rec));
|
SET_REGNO_REG_SET (reg_set_bitmap, DF_REF_REGNO (*def_rec));
|
}
|
}
|
|
|
/* Top level function to create an assignment hash table.
|
/* Top level function to create an assignment hash table.
|
|
|
Assignment entries are placed in the hash table if
|
Assignment entries are placed in the hash table if
|
- they are of the form (set (pseudo-reg) src),
|
- they are of the form (set (pseudo-reg) src),
|
- src is something we want to perform const/copy propagation on,
|
- src is something we want to perform const/copy propagation on,
|
- none of the operands or target are subsequently modified in the block
|
- none of the operands or target are subsequently modified in the block
|
|
|
Currently src must be a pseudo-reg or a const_int.
|
Currently src must be a pseudo-reg or a const_int.
|
|
|
TABLE is the table computed. */
|
TABLE is the table computed. */
|
|
|
static void
|
static void
|
compute_hash_table_work (struct hash_table_d *table)
|
compute_hash_table_work (struct hash_table_d *table)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Allocate vars to track sets of regs. */
|
/* Allocate vars to track sets of regs. */
|
reg_set_bitmap = ALLOC_REG_SET (NULL);
|
reg_set_bitmap = ALLOC_REG_SET (NULL);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
/* Reset tables used to keep track of what's not yet invalid [since
|
/* Reset tables used to keep track of what's not yet invalid [since
|
the end of the block]. */
|
the end of the block]. */
|
CLEAR_REG_SET (reg_set_bitmap);
|
CLEAR_REG_SET (reg_set_bitmap);
|
|
|
/* Go over all insns from the last to the first. This is convenient
|
/* Go over all insns from the last to the first. This is convenient
|
for tracking available registers, i.e. not set between INSN and
|
for tracking available registers, i.e. not set between INSN and
|
the end of the basic block BB. */
|
the end of the basic block BB. */
|
FOR_BB_INSNS_REVERSE (bb, insn)
|
FOR_BB_INSNS_REVERSE (bb, insn)
|
{
|
{
|
/* Only real insns are interesting. */
|
/* Only real insns are interesting. */
|
if (!NONDEBUG_INSN_P (insn))
|
if (!NONDEBUG_INSN_P (insn))
|
continue;
|
continue;
|
|
|
/* Record interesting sets from INSN in the hash table. */
|
/* Record interesting sets from INSN in the hash table. */
|
hash_scan_insn (insn, table);
|
hash_scan_insn (insn, table);
|
|
|
/* Any registers set in INSN will make SETs above it not AVAIL. */
|
/* Any registers set in INSN will make SETs above it not AVAIL. */
|
make_set_regs_unavailable (insn);
|
make_set_regs_unavailable (insn);
|
}
|
}
|
|
|
/* Insert implicit sets in the hash table, pretending they appear as
|
/* Insert implicit sets in the hash table, pretending they appear as
|
insns at the head of the basic block. */
|
insns at the head of the basic block. */
|
if (implicit_sets[bb->index] != NULL_RTX)
|
if (implicit_sets[bb->index] != NULL_RTX)
|
hash_scan_set (implicit_sets[bb->index], BB_HEAD (bb), table, true);
|
hash_scan_set (implicit_sets[bb->index], BB_HEAD (bb), table, true);
|
}
|
}
|
|
|
FREE_REG_SET (reg_set_bitmap);
|
FREE_REG_SET (reg_set_bitmap);
|
}
|
}
|
|
|
/* Allocate space for the set/expr hash TABLE.
|
/* Allocate space for the set/expr hash TABLE.
|
It is used to determine the number of buckets to use. */
|
It is used to determine the number of buckets to use. */
|
|
|
static void
|
static void
|
alloc_hash_table (struct hash_table_d *table)
|
alloc_hash_table (struct hash_table_d *table)
|
{
|
{
|
int n;
|
int n;
|
|
|
n = get_max_insn_count ();
|
n = get_max_insn_count ();
|
|
|
table->size = n / 4;
|
table->size = n / 4;
|
if (table->size < 11)
|
if (table->size < 11)
|
table->size = 11;
|
table->size = 11;
|
|
|
/* Attempt to maintain efficient use of hash table.
|
/* Attempt to maintain efficient use of hash table.
|
Making it an odd number is simplest for now.
|
Making it an odd number is simplest for now.
|
??? Later take some measurements. */
|
??? Later take some measurements. */
|
table->size |= 1;
|
table->size |= 1;
|
n = table->size * sizeof (struct expr *);
|
n = table->size * sizeof (struct expr *);
|
table->table = XNEWVAR (struct expr *, n);
|
table->table = XNEWVAR (struct expr *, n);
|
}
|
}
|
|
|
/* Free things allocated by alloc_hash_table. */
|
/* Free things allocated by alloc_hash_table. */
|
|
|
static void
|
static void
|
free_hash_table (struct hash_table_d *table)
|
free_hash_table (struct hash_table_d *table)
|
{
|
{
|
free (table->table);
|
free (table->table);
|
}
|
}
|
|
|
/* Compute the hash TABLE for doing copy/const propagation or
|
/* Compute the hash TABLE for doing copy/const propagation or
|
expression hash table. */
|
expression hash table. */
|
|
|
static void
|
static void
|
compute_hash_table (struct hash_table_d *table)
|
compute_hash_table (struct hash_table_d *table)
|
{
|
{
|
/* Initialize count of number of entries in hash table. */
|
/* Initialize count of number of entries in hash table. */
|
table->n_elems = 0;
|
table->n_elems = 0;
|
memset (table->table, 0, table->size * sizeof (struct expr *));
|
memset (table->table, 0, table->size * sizeof (struct expr *));
|
|
|
compute_hash_table_work (table);
|
compute_hash_table_work (table);
|
}
|
}
|
|
|
/* Expression tracking support. */
|
/* Expression tracking support. */
|
|
|
/* Lookup REGNO in the set TABLE. The result is a pointer to the
|
/* Lookup REGNO in the set TABLE. The result is a pointer to the
|
table entry, or NULL if not found. */
|
table entry, or NULL if not found. */
|
|
|
static struct expr *
|
static struct expr *
|
lookup_set (unsigned int regno, struct hash_table_d *table)
|
lookup_set (unsigned int regno, struct hash_table_d *table)
|
{
|
{
|
unsigned int hash = hash_set (regno, table->size);
|
unsigned int hash = hash_set (regno, table->size);
|
struct expr *expr;
|
struct expr *expr;
|
|
|
expr = table->table[hash];
|
expr = table->table[hash];
|
|
|
while (expr && REGNO (expr->dest) != regno)
|
while (expr && REGNO (expr->dest) != regno)
|
expr = expr->next_same_hash;
|
expr = expr->next_same_hash;
|
|
|
return expr;
|
return expr;
|
}
|
}
|
|
|
/* Return the next entry for REGNO in list EXPR. */
|
/* Return the next entry for REGNO in list EXPR. */
|
|
|
static struct expr *
|
static struct expr *
|
next_set (unsigned int regno, struct expr *expr)
|
next_set (unsigned int regno, struct expr *expr)
|
{
|
{
|
do
|
do
|
expr = expr->next_same_hash;
|
expr = expr->next_same_hash;
|
while (expr && REGNO (expr->dest) != regno);
|
while (expr && REGNO (expr->dest) != regno);
|
|
|
return expr;
|
return expr;
|
}
|
}
|
|
|
/* Reset tables used to keep track of what's still available [since the
|
/* Reset tables used to keep track of what's still available [since the
|
start of the block]. */
|
start of the block]. */
|
|
|
static void
|
static void
|
reset_opr_set_tables (void)
|
reset_opr_set_tables (void)
|
{
|
{
|
/* Maintain a bitmap of which regs have been set since beginning of
|
/* Maintain a bitmap of which regs have been set since beginning of
|
the block. */
|
the block. */
|
CLEAR_REG_SET (reg_set_bitmap);
|
CLEAR_REG_SET (reg_set_bitmap);
|
}
|
}
|
|
|
/* Return nonzero if the register X has not been set yet [since the
|
/* Return nonzero if the register X has not been set yet [since the
|
start of the basic block containing INSN]. */
|
start of the basic block containing INSN]. */
|
|
|
static int
|
static int
|
reg_not_set_p (const_rtx x, const_rtx insn ATTRIBUTE_UNUSED)
|
reg_not_set_p (const_rtx x, const_rtx insn ATTRIBUTE_UNUSED)
|
{
|
{
|
return ! REGNO_REG_SET_P (reg_set_bitmap, REGNO (x));
|
return ! REGNO_REG_SET_P (reg_set_bitmap, REGNO (x));
|
}
|
}
|
|
|
/* Record things set by INSN.
|
/* Record things set by INSN.
|
This data is used by reg_not_set_p. */
|
This data is used by reg_not_set_p. */
|
|
|
static void
|
static void
|
mark_oprs_set (rtx insn)
|
mark_oprs_set (rtx insn)
|
{
|
{
|
struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
|
struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
|
df_ref *def_rec;
|
df_ref *def_rec;
|
|
|
for (def_rec = DF_INSN_INFO_DEFS (insn_info); *def_rec; def_rec++)
|
for (def_rec = DF_INSN_INFO_DEFS (insn_info); *def_rec; def_rec++)
|
SET_REGNO_REG_SET (reg_set_bitmap, DF_REF_REGNO (*def_rec));
|
SET_REGNO_REG_SET (reg_set_bitmap, DF_REF_REGNO (*def_rec));
|
}
|
}
|
|
|
/* Compute copy/constant propagation working variables. */
|
/* Compute copy/constant propagation working variables. */
|
|
|
/* Local properties of assignments. */
|
/* Local properties of assignments. */
|
static sbitmap *cprop_avloc;
|
static sbitmap *cprop_avloc;
|
static sbitmap *cprop_kill;
|
static sbitmap *cprop_kill;
|
|
|
/* Global properties of assignments (computed from the local properties). */
|
/* Global properties of assignments (computed from the local properties). */
|
static sbitmap *cprop_avin;
|
static sbitmap *cprop_avin;
|
static sbitmap *cprop_avout;
|
static sbitmap *cprop_avout;
|
|
|
/* Allocate vars used for copy/const propagation. N_BLOCKS is the number of
|
/* Allocate vars used for copy/const propagation. N_BLOCKS is the number of
|
basic blocks. N_SETS is the number of sets. */
|
basic blocks. N_SETS is the number of sets. */
|
|
|
static void
|
static void
|
alloc_cprop_mem (int n_blocks, int n_sets)
|
alloc_cprop_mem (int n_blocks, int n_sets)
|
{
|
{
|
cprop_avloc = sbitmap_vector_alloc (n_blocks, n_sets);
|
cprop_avloc = sbitmap_vector_alloc (n_blocks, n_sets);
|
cprop_kill = sbitmap_vector_alloc (n_blocks, n_sets);
|
cprop_kill = sbitmap_vector_alloc (n_blocks, n_sets);
|
|
|
cprop_avin = sbitmap_vector_alloc (n_blocks, n_sets);
|
cprop_avin = sbitmap_vector_alloc (n_blocks, n_sets);
|
cprop_avout = sbitmap_vector_alloc (n_blocks, n_sets);
|
cprop_avout = sbitmap_vector_alloc (n_blocks, n_sets);
|
}
|
}
|
|
|
/* Free vars used by copy/const propagation. */
|
/* Free vars used by copy/const propagation. */
|
|
|
static void
|
static void
|
free_cprop_mem (void)
|
free_cprop_mem (void)
|
{
|
{
|
sbitmap_vector_free (cprop_avloc);
|
sbitmap_vector_free (cprop_avloc);
|
sbitmap_vector_free (cprop_kill);
|
sbitmap_vector_free (cprop_kill);
|
sbitmap_vector_free (cprop_avin);
|
sbitmap_vector_free (cprop_avin);
|
sbitmap_vector_free (cprop_avout);
|
sbitmap_vector_free (cprop_avout);
|
}
|
}
|
|
|
/* Compute the local properties of each recorded expression.
|
/* Compute the local properties of each recorded expression.
|
|
|
Local properties are those that are defined by the block, irrespective of
|
Local properties are those that are defined by the block, irrespective of
|
other blocks.
|
other blocks.
|
|
|
An expression is killed in a block if its operands, either DEST or SRC, are
|
An expression is killed in a block if its operands, either DEST or SRC, are
|
modified in the block.
|
modified in the block.
|
|
|
An expression is computed (locally available) in a block if it is computed
|
An expression is computed (locally available) in a block if it is computed
|
at least once and expression would contain the same value if the
|
at least once and expression would contain the same value if the
|
computation was moved to the end of the block.
|
computation was moved to the end of the block.
|
|
|
KILL and COMP are destination sbitmaps for recording local properties. */
|
KILL and COMP are destination sbitmaps for recording local properties. */
|
|
|
static void
|
static void
|
compute_local_properties (sbitmap *kill, sbitmap *comp,
|
compute_local_properties (sbitmap *kill, sbitmap *comp,
|
struct hash_table_d *table)
|
struct hash_table_d *table)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
|
|
/* Initialize the bitmaps that were passed in. */
|
/* Initialize the bitmaps that were passed in. */
|
sbitmap_vector_zero (kill, last_basic_block);
|
sbitmap_vector_zero (kill, last_basic_block);
|
sbitmap_vector_zero (comp, last_basic_block);
|
sbitmap_vector_zero (comp, last_basic_block);
|
|
|
for (i = 0; i < table->size; i++)
|
for (i = 0; i < table->size; i++)
|
{
|
{
|
struct expr *expr;
|
struct expr *expr;
|
|
|
for (expr = table->table[i]; expr != NULL; expr = expr->next_same_hash)
|
for (expr = table->table[i]; expr != NULL; expr = expr->next_same_hash)
|
{
|
{
|
int indx = expr->bitmap_index;
|
int indx = expr->bitmap_index;
|
df_ref def;
|
df_ref def;
|
struct occr *occr;
|
struct occr *occr;
|
|
|
/* For each definition of the destination pseudo-reg, the expression
|
/* For each definition of the destination pseudo-reg, the expression
|
is killed in the block where the definition is. */
|
is killed in the block where the definition is. */
|
for (def = DF_REG_DEF_CHAIN (REGNO (expr->dest));
|
for (def = DF_REG_DEF_CHAIN (REGNO (expr->dest));
|
def; def = DF_REF_NEXT_REG (def))
|
def; def = DF_REF_NEXT_REG (def))
|
SET_BIT (kill[DF_REF_BB (def)->index], indx);
|
SET_BIT (kill[DF_REF_BB (def)->index], indx);
|
|
|
/* If the source is a pseudo-reg, for each definition of the source,
|
/* If the source is a pseudo-reg, for each definition of the source,
|
the expression is killed in the block where the definition is. */
|
the expression is killed in the block where the definition is. */
|
if (REG_P (expr->src))
|
if (REG_P (expr->src))
|
for (def = DF_REG_DEF_CHAIN (REGNO (expr->src));
|
for (def = DF_REG_DEF_CHAIN (REGNO (expr->src));
|
def; def = DF_REF_NEXT_REG (def))
|
def; def = DF_REF_NEXT_REG (def))
|
SET_BIT (kill[DF_REF_BB (def)->index], indx);
|
SET_BIT (kill[DF_REF_BB (def)->index], indx);
|
|
|
/* The occurrences recorded in avail_occr are exactly those that
|
/* The occurrences recorded in avail_occr are exactly those that
|
are locally available in the block where they are. */
|
are locally available in the block where they are. */
|
for (occr = expr->avail_occr; occr != NULL; occr = occr->next)
|
for (occr = expr->avail_occr; occr != NULL; occr = occr->next)
|
{
|
{
|
SET_BIT (comp[BLOCK_FOR_INSN (occr->insn)->index], indx);
|
SET_BIT (comp[BLOCK_FOR_INSN (occr->insn)->index], indx);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Hash table support. */
|
/* Hash table support. */
|
|
|
/* Top level routine to do the dataflow analysis needed by copy/const
|
/* Top level routine to do the dataflow analysis needed by copy/const
|
propagation. */
|
propagation. */
|
|
|
static void
|
static void
|
compute_cprop_data (void)
|
compute_cprop_data (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
compute_local_properties (cprop_kill, cprop_avloc, &set_hash_table);
|
compute_local_properties (cprop_kill, cprop_avloc, &set_hash_table);
|
compute_available (cprop_avloc, cprop_kill, cprop_avout, cprop_avin);
|
compute_available (cprop_avloc, cprop_kill, cprop_avout, cprop_avin);
|
|
|
/* Merge implicit sets into CPROP_AVIN. They are always available at the
|
/* Merge implicit sets into CPROP_AVIN. They are always available at the
|
entry of their basic block. We need to do this because 1) implicit sets
|
entry of their basic block. We need to do this because 1) implicit sets
|
aren't recorded for the local pass so they cannot be propagated within
|
aren't recorded for the local pass so they cannot be propagated within
|
their basic block by this pass and 2) the global pass would otherwise
|
their basic block by this pass and 2) the global pass would otherwise
|
propagate them only in the successors of their basic block. */
|
propagate them only in the successors of their basic block. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
int index = implicit_set_indexes[bb->index];
|
int index = implicit_set_indexes[bb->index];
|
if (index != -1)
|
if (index != -1)
|
SET_BIT (cprop_avin[bb->index], index);
|
SET_BIT (cprop_avin[bb->index], index);
|
}
|
}
|
}
|
}
|
|
|
/* Copy/constant propagation. */
|
/* Copy/constant propagation. */
|
|
|
/* Maximum number of register uses in an insn that we handle. */
|
/* Maximum number of register uses in an insn that we handle. */
|
#define MAX_USES 8
|
#define MAX_USES 8
|
|
|
/* Table of uses (registers, both hard and pseudo) found in an insn.
|
/* Table of uses (registers, both hard and pseudo) found in an insn.
|
Allocated statically to avoid alloc/free complexity and overhead. */
|
Allocated statically to avoid alloc/free complexity and overhead. */
|
static rtx reg_use_table[MAX_USES];
|
static rtx reg_use_table[MAX_USES];
|
|
|
/* Index into `reg_use_table' while building it. */
|
/* Index into `reg_use_table' while building it. */
|
static unsigned reg_use_count;
|
static unsigned reg_use_count;
|
|
|
/* Set up a list of register numbers used in INSN. The found uses are stored
|
/* Set up a list of register numbers used in INSN. The found uses are stored
|
in `reg_use_table'. `reg_use_count' is initialized to zero before entry,
|
in `reg_use_table'. `reg_use_count' is initialized to zero before entry,
|
and contains the number of uses in the table upon exit.
|
and contains the number of uses in the table upon exit.
|
|
|
??? If a register appears multiple times we will record it multiple times.
|
??? If a register appears multiple times we will record it multiple times.
|
This doesn't hurt anything but it will slow things down. */
|
This doesn't hurt anything but it will slow things down. */
|
|
|
static void
|
static void
|
find_used_regs (rtx *xptr, void *data ATTRIBUTE_UNUSED)
|
find_used_regs (rtx *xptr, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
int i, j;
|
int i, j;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *fmt;
|
const char *fmt;
|
rtx x = *xptr;
|
rtx x = *xptr;
|
|
|
/* repeat is used to turn tail-recursion into iteration since GCC
|
/* repeat is used to turn tail-recursion into iteration since GCC
|
can't do it when there's no return value. */
|
can't do it when there's no return value. */
|
repeat:
|
repeat:
|
if (x == 0)
|
if (x == 0)
|
return;
|
return;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
if (REG_P (x))
|
if (REG_P (x))
|
{
|
{
|
if (reg_use_count == MAX_USES)
|
if (reg_use_count == MAX_USES)
|
return;
|
return;
|
|
|
reg_use_table[reg_use_count] = x;
|
reg_use_table[reg_use_count] = x;
|
reg_use_count++;
|
reg_use_count++;
|
}
|
}
|
|
|
/* Recursively scan the operands of this expression. */
|
/* Recursively scan the operands of this expression. */
|
|
|
for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
/* If we are about to do the last recursive call
|
/* If we are about to do the last recursive call
|
needed at this level, change it into iteration.
|
needed at this level, change it into iteration.
|
This function is called enough to be worth it. */
|
This function is called enough to be worth it. */
|
if (i == 0)
|
if (i == 0)
|
{
|
{
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
|
|
find_used_regs (&XEXP (x, i), data);
|
find_used_regs (&XEXP (x, i), data);
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
find_used_regs (&XVECEXP (x, i, j), data);
|
find_used_regs (&XVECEXP (x, i, j), data);
|
}
|
}
|
}
|
}
|
|
|
/* Try to replace all uses of FROM in INSN with TO.
|
/* Try to replace all uses of FROM in INSN with TO.
|
Return nonzero if successful. */
|
Return nonzero if successful. */
|
|
|
static int
|
static int
|
try_replace_reg (rtx from, rtx to, rtx insn)
|
try_replace_reg (rtx from, rtx to, rtx insn)
|
{
|
{
|
rtx note = find_reg_equal_equiv_note (insn);
|
rtx note = find_reg_equal_equiv_note (insn);
|
rtx src = 0;
|
rtx src = 0;
|
int success = 0;
|
int success = 0;
|
rtx set = single_set (insn);
|
rtx set = single_set (insn);
|
|
|
/* Usually we substitute easy stuff, so we won't copy everything.
|
/* Usually we substitute easy stuff, so we won't copy everything.
|
We however need to take care to not duplicate non-trivial CONST
|
We however need to take care to not duplicate non-trivial CONST
|
expressions. */
|
expressions. */
|
to = copy_rtx (to);
|
to = copy_rtx (to);
|
|
|
validate_replace_src_group (from, to, insn);
|
validate_replace_src_group (from, to, insn);
|
if (num_changes_pending () && apply_change_group ())
|
if (num_changes_pending () && apply_change_group ())
|
success = 1;
|
success = 1;
|
|
|
/* Try to simplify SET_SRC if we have substituted a constant. */
|
/* Try to simplify SET_SRC if we have substituted a constant. */
|
if (success && set && CONSTANT_P (to))
|
if (success && set && CONSTANT_P (to))
|
{
|
{
|
src = simplify_rtx (SET_SRC (set));
|
src = simplify_rtx (SET_SRC (set));
|
|
|
if (src)
|
if (src)
|
validate_change (insn, &SET_SRC (set), src, 0);
|
validate_change (insn, &SET_SRC (set), src, 0);
|
}
|
}
|
|
|
/* If there is already a REG_EQUAL note, update the expression in it
|
/* If there is already a REG_EQUAL note, update the expression in it
|
with our replacement. */
|
with our replacement. */
|
if (note != 0 && REG_NOTE_KIND (note) == REG_EQUAL)
|
if (note != 0 && REG_NOTE_KIND (note) == REG_EQUAL)
|
set_unique_reg_note (insn, REG_EQUAL,
|
set_unique_reg_note (insn, REG_EQUAL,
|
simplify_replace_rtx (XEXP (note, 0), from, to));
|
simplify_replace_rtx (XEXP (note, 0), from, to));
|
if (!success && set && reg_mentioned_p (from, SET_SRC (set)))
|
if (!success && set && reg_mentioned_p (from, SET_SRC (set)))
|
{
|
{
|
/* If above failed and this is a single set, try to simplify the source
|
/* If above failed and this is a single set, try to simplify the source
|
of the set given our substitution. We could perhaps try this for
|
of the set given our substitution. We could perhaps try this for
|
multiple SETs, but it probably won't buy us anything. */
|
multiple SETs, but it probably won't buy us anything. */
|
src = simplify_replace_rtx (SET_SRC (set), from, to);
|
src = simplify_replace_rtx (SET_SRC (set), from, to);
|
|
|
if (!rtx_equal_p (src, SET_SRC (set))
|
if (!rtx_equal_p (src, SET_SRC (set))
|
&& validate_change (insn, &SET_SRC (set), src, 0))
|
&& validate_change (insn, &SET_SRC (set), src, 0))
|
success = 1;
|
success = 1;
|
|
|
/* If we've failed perform the replacement, have a single SET to
|
/* If we've failed perform the replacement, have a single SET to
|
a REG destination and don't yet have a note, add a REG_EQUAL note
|
a REG destination and don't yet have a note, add a REG_EQUAL note
|
to not lose information. */
|
to not lose information. */
|
if (!success && note == 0 && set != 0 && REG_P (SET_DEST (set)))
|
if (!success && note == 0 && set != 0 && REG_P (SET_DEST (set)))
|
note = set_unique_reg_note (insn, REG_EQUAL, copy_rtx (src));
|
note = set_unique_reg_note (insn, REG_EQUAL, copy_rtx (src));
|
}
|
}
|
|
|
if (set && MEM_P (SET_DEST (set)) && reg_mentioned_p (from, SET_DEST (set)))
|
if (set && MEM_P (SET_DEST (set)) && reg_mentioned_p (from, SET_DEST (set)))
|
{
|
{
|
/* Registers can also appear as uses in SET_DEST if it is a MEM.
|
/* Registers can also appear as uses in SET_DEST if it is a MEM.
|
We could perhaps try this for multiple SETs, but it probably
|
We could perhaps try this for multiple SETs, but it probably
|
won't buy us anything. */
|
won't buy us anything. */
|
rtx dest = simplify_replace_rtx (SET_DEST (set), from, to);
|
rtx dest = simplify_replace_rtx (SET_DEST (set), from, to);
|
|
|
if (!rtx_equal_p (dest, SET_DEST (set))
|
if (!rtx_equal_p (dest, SET_DEST (set))
|
&& validate_change (insn, &SET_DEST (set), dest, 0))
|
&& validate_change (insn, &SET_DEST (set), dest, 0))
|
success = 1;
|
success = 1;
|
}
|
}
|
|
|
/* REG_EQUAL may get simplified into register.
|
/* REG_EQUAL may get simplified into register.
|
We don't allow that. Remove that note. This code ought
|
We don't allow that. Remove that note. This code ought
|
not to happen, because previous code ought to synthesize
|
not to happen, because previous code ought to synthesize
|
reg-reg move, but be on the safe side. */
|
reg-reg move, but be on the safe side. */
|
if (note && REG_NOTE_KIND (note) == REG_EQUAL && REG_P (XEXP (note, 0)))
|
if (note && REG_NOTE_KIND (note) == REG_EQUAL && REG_P (XEXP (note, 0)))
|
remove_note (insn, note);
|
remove_note (insn, note);
|
|
|
return success;
|
return success;
|
}
|
}
|
|
|
/* Find a set of REGNOs that are available on entry to INSN's block. Return
|
/* Find a set of REGNOs that are available on entry to INSN's block. Return
|
NULL no such set is found. */
|
NULL no such set is found. */
|
|
|
static struct expr *
|
static struct expr *
|
find_avail_set (int regno, rtx insn)
|
find_avail_set (int regno, rtx insn)
|
{
|
{
|
/* SET1 contains the last set found that can be returned to the caller for
|
/* SET1 contains the last set found that can be returned to the caller for
|
use in a substitution. */
|
use in a substitution. */
|
struct expr *set1 = 0;
|
struct expr *set1 = 0;
|
|
|
/* Loops are not possible here. To get a loop we would need two sets
|
/* Loops are not possible here. To get a loop we would need two sets
|
available at the start of the block containing INSN. i.e. we would
|
available at the start of the block containing INSN. i.e. we would
|
need two sets like this available at the start of the block:
|
need two sets like this available at the start of the block:
|
|
|
(set (reg X) (reg Y))
|
(set (reg X) (reg Y))
|
(set (reg Y) (reg X))
|
(set (reg Y) (reg X))
|
|
|
This can not happen since the set of (reg Y) would have killed the
|
This can not happen since the set of (reg Y) would have killed the
|
set of (reg X) making it unavailable at the start of this block. */
|
set of (reg X) making it unavailable at the start of this block. */
|
while (1)
|
while (1)
|
{
|
{
|
rtx src;
|
rtx src;
|
struct expr *set = lookup_set (regno, &set_hash_table);
|
struct expr *set = lookup_set (regno, &set_hash_table);
|
|
|
/* Find a set that is available at the start of the block
|
/* Find a set that is available at the start of the block
|
which contains INSN. */
|
which contains INSN. */
|
while (set)
|
while (set)
|
{
|
{
|
if (TEST_BIT (cprop_avin[BLOCK_FOR_INSN (insn)->index],
|
if (TEST_BIT (cprop_avin[BLOCK_FOR_INSN (insn)->index],
|
set->bitmap_index))
|
set->bitmap_index))
|
break;
|
break;
|
set = next_set (regno, set);
|
set = next_set (regno, set);
|
}
|
}
|
|
|
/* If no available set was found we've reached the end of the
|
/* If no available set was found we've reached the end of the
|
(possibly empty) copy chain. */
|
(possibly empty) copy chain. */
|
if (set == 0)
|
if (set == 0)
|
break;
|
break;
|
|
|
src = set->src;
|
src = set->src;
|
|
|
/* We know the set is available.
|
/* We know the set is available.
|
Now check that SRC is locally anticipatable (i.e. none of the
|
Now check that SRC is locally anticipatable (i.e. none of the
|
source operands have changed since the start of the block).
|
source operands have changed since the start of the block).
|
|
|
If the source operand changed, we may still use it for the next
|
If the source operand changed, we may still use it for the next
|
iteration of this loop, but we may not use it for substitutions. */
|
iteration of this loop, but we may not use it for substitutions. */
|
|
|
if (cprop_constant_p (src) || reg_not_set_p (src, insn))
|
if (cprop_constant_p (src) || reg_not_set_p (src, insn))
|
set1 = set;
|
set1 = set;
|
|
|
/* If the source of the set is anything except a register, then
|
/* If the source of the set is anything except a register, then
|
we have reached the end of the copy chain. */
|
we have reached the end of the copy chain. */
|
if (! REG_P (src))
|
if (! REG_P (src))
|
break;
|
break;
|
|
|
/* Follow the copy chain, i.e. start another iteration of the loop
|
/* Follow the copy chain, i.e. start another iteration of the loop
|
and see if we have an available copy into SRC. */
|
and see if we have an available copy into SRC. */
|
regno = REGNO (src);
|
regno = REGNO (src);
|
}
|
}
|
|
|
/* SET1 holds the last set that was available and anticipatable at
|
/* SET1 holds the last set that was available and anticipatable at
|
INSN. */
|
INSN. */
|
return set1;
|
return set1;
|
}
|
}
|
|
|
/* Subroutine of cprop_insn that tries to propagate constants into
|
/* Subroutine of cprop_insn that tries to propagate constants into
|
JUMP_INSNS. JUMP must be a conditional jump. If SETCC is non-NULL
|
JUMP_INSNS. JUMP must be a conditional jump. If SETCC is non-NULL
|
it is the instruction that immediately precedes JUMP, and must be a
|
it is the instruction that immediately precedes JUMP, and must be a
|
single SET of a register. FROM is what we will try to replace,
|
single SET of a register. FROM is what we will try to replace,
|
SRC is the constant we will try to substitute for it. Return nonzero
|
SRC is the constant we will try to substitute for it. Return nonzero
|
if a change was made. */
|
if a change was made. */
|
|
|
static int
|
static int
|
cprop_jump (basic_block bb, rtx setcc, rtx jump, rtx from, rtx src)
|
cprop_jump (basic_block bb, rtx setcc, rtx jump, rtx from, rtx src)
|
{
|
{
|
rtx new_rtx, set_src, note_src;
|
rtx new_rtx, set_src, note_src;
|
rtx set = pc_set (jump);
|
rtx set = pc_set (jump);
|
rtx note = find_reg_equal_equiv_note (jump);
|
rtx note = find_reg_equal_equiv_note (jump);
|
|
|
if (note)
|
if (note)
|
{
|
{
|
note_src = XEXP (note, 0);
|
note_src = XEXP (note, 0);
|
if (GET_CODE (note_src) == EXPR_LIST)
|
if (GET_CODE (note_src) == EXPR_LIST)
|
note_src = NULL_RTX;
|
note_src = NULL_RTX;
|
}
|
}
|
else note_src = NULL_RTX;
|
else note_src = NULL_RTX;
|
|
|
/* Prefer REG_EQUAL notes except those containing EXPR_LISTs. */
|
/* Prefer REG_EQUAL notes except those containing EXPR_LISTs. */
|
set_src = note_src ? note_src : SET_SRC (set);
|
set_src = note_src ? note_src : SET_SRC (set);
|
|
|
/* First substitute the SETCC condition into the JUMP instruction,
|
/* First substitute the SETCC condition into the JUMP instruction,
|
then substitute that given values into this expanded JUMP. */
|
then substitute that given values into this expanded JUMP. */
|
if (setcc != NULL_RTX
|
if (setcc != NULL_RTX
|
&& !modified_between_p (from, setcc, jump)
|
&& !modified_between_p (from, setcc, jump)
|
&& !modified_between_p (src, setcc, jump))
|
&& !modified_between_p (src, setcc, jump))
|
{
|
{
|
rtx setcc_src;
|
rtx setcc_src;
|
rtx setcc_set = single_set (setcc);
|
rtx setcc_set = single_set (setcc);
|
rtx setcc_note = find_reg_equal_equiv_note (setcc);
|
rtx setcc_note = find_reg_equal_equiv_note (setcc);
|
setcc_src = (setcc_note && GET_CODE (XEXP (setcc_note, 0)) != EXPR_LIST)
|
setcc_src = (setcc_note && GET_CODE (XEXP (setcc_note, 0)) != EXPR_LIST)
|
? XEXP (setcc_note, 0) : SET_SRC (setcc_set);
|
? XEXP (setcc_note, 0) : SET_SRC (setcc_set);
|
set_src = simplify_replace_rtx (set_src, SET_DEST (setcc_set),
|
set_src = simplify_replace_rtx (set_src, SET_DEST (setcc_set),
|
setcc_src);
|
setcc_src);
|
}
|
}
|
else
|
else
|
setcc = NULL_RTX;
|
setcc = NULL_RTX;
|
|
|
new_rtx = simplify_replace_rtx (set_src, from, src);
|
new_rtx = simplify_replace_rtx (set_src, from, src);
|
|
|
/* If no simplification can be made, then try the next register. */
|
/* If no simplification can be made, then try the next register. */
|
if (rtx_equal_p (new_rtx, SET_SRC (set)))
|
if (rtx_equal_p (new_rtx, SET_SRC (set)))
|
return 0;
|
return 0;
|
|
|
/* If this is now a no-op delete it, otherwise this must be a valid insn. */
|
/* If this is now a no-op delete it, otherwise this must be a valid insn. */
|
if (new_rtx == pc_rtx)
|
if (new_rtx == pc_rtx)
|
delete_insn (jump);
|
delete_insn (jump);
|
else
|
else
|
{
|
{
|
/* Ensure the value computed inside the jump insn to be equivalent
|
/* Ensure the value computed inside the jump insn to be equivalent
|
to one computed by setcc. */
|
to one computed by setcc. */
|
if (setcc && modified_in_p (new_rtx, setcc))
|
if (setcc && modified_in_p (new_rtx, setcc))
|
return 0;
|
return 0;
|
if (! validate_unshare_change (jump, &SET_SRC (set), new_rtx, 0))
|
if (! validate_unshare_change (jump, &SET_SRC (set), new_rtx, 0))
|
{
|
{
|
/* When (some) constants are not valid in a comparison, and there
|
/* When (some) constants are not valid in a comparison, and there
|
are two registers to be replaced by constants before the entire
|
are two registers to be replaced by constants before the entire
|
comparison can be folded into a constant, we need to keep
|
comparison can be folded into a constant, we need to keep
|
intermediate information in REG_EQUAL notes. For targets with
|
intermediate information in REG_EQUAL notes. For targets with
|
separate compare insns, such notes are added by try_replace_reg.
|
separate compare insns, such notes are added by try_replace_reg.
|
When we have a combined compare-and-branch instruction, however,
|
When we have a combined compare-and-branch instruction, however,
|
we need to attach a note to the branch itself to make this
|
we need to attach a note to the branch itself to make this
|
optimization work. */
|
optimization work. */
|
|
|
if (!rtx_equal_p (new_rtx, note_src))
|
if (!rtx_equal_p (new_rtx, note_src))
|
set_unique_reg_note (jump, REG_EQUAL, copy_rtx (new_rtx));
|
set_unique_reg_note (jump, REG_EQUAL, copy_rtx (new_rtx));
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Remove REG_EQUAL note after simplification. */
|
/* Remove REG_EQUAL note after simplification. */
|
if (note_src)
|
if (note_src)
|
remove_note (jump, note);
|
remove_note (jump, note);
|
}
|
}
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
/* Delete the cc0 setter. */
|
/* Delete the cc0 setter. */
|
if (setcc != NULL && CC0_P (SET_DEST (single_set (setcc))))
|
if (setcc != NULL && CC0_P (SET_DEST (single_set (setcc))))
|
delete_insn (setcc);
|
delete_insn (setcc);
|
#endif
|
#endif
|
|
|
global_const_prop_count++;
|
global_const_prop_count++;
|
if (dump_file != NULL)
|
if (dump_file != NULL)
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"GLOBAL CONST-PROP: Replacing reg %d in jump_insn %d with"
|
"GLOBAL CONST-PROP: Replacing reg %d in jump_insn %d with"
|
"constant ", REGNO (from), INSN_UID (jump));
|
"constant ", REGNO (from), INSN_UID (jump));
|
print_rtl (dump_file, src);
|
print_rtl (dump_file, src);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
purge_dead_edges (bb);
|
purge_dead_edges (bb);
|
|
|
/* If a conditional jump has been changed into unconditional jump, remove
|
/* If a conditional jump has been changed into unconditional jump, remove
|
the jump and make the edge fallthru - this is always called in
|
the jump and make the edge fallthru - this is always called in
|
cfglayout mode. */
|
cfglayout mode. */
|
if (new_rtx != pc_rtx && simplejump_p (jump))
|
if (new_rtx != pc_rtx && simplejump_p (jump))
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
if (e->dest != EXIT_BLOCK_PTR
|
if (e->dest != EXIT_BLOCK_PTR
|
&& BB_HEAD (e->dest) == JUMP_LABEL (jump))
|
&& BB_HEAD (e->dest) == JUMP_LABEL (jump))
|
{
|
{
|
e->flags |= EDGE_FALLTHRU;
|
e->flags |= EDGE_FALLTHRU;
|
break;
|
break;
|
}
|
}
|
delete_insn (jump);
|
delete_insn (jump);
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Subroutine of cprop_insn that tries to propagate constants. FROM is what
|
/* Subroutine of cprop_insn that tries to propagate constants. FROM is what
|
we will try to replace, SRC is the constant we will try to substitute for
|
we will try to replace, SRC is the constant we will try to substitute for
|
it and INSN is the instruction where this will be happening. */
|
it and INSN is the instruction where this will be happening. */
|
|
|
static int
|
static int
|
constprop_register (rtx from, rtx src, rtx insn)
|
constprop_register (rtx from, rtx src, rtx insn)
|
{
|
{
|
rtx sset;
|
rtx sset;
|
|
|
/* Check for reg or cc0 setting instructions followed by
|
/* Check for reg or cc0 setting instructions followed by
|
conditional branch instructions first. */
|
conditional branch instructions first. */
|
if ((sset = single_set (insn)) != NULL
|
if ((sset = single_set (insn)) != NULL
|
&& NEXT_INSN (insn)
|
&& NEXT_INSN (insn)
|
&& any_condjump_p (NEXT_INSN (insn)) && onlyjump_p (NEXT_INSN (insn)))
|
&& any_condjump_p (NEXT_INSN (insn)) && onlyjump_p (NEXT_INSN (insn)))
|
{
|
{
|
rtx dest = SET_DEST (sset);
|
rtx dest = SET_DEST (sset);
|
if ((REG_P (dest) || CC0_P (dest))
|
if ((REG_P (dest) || CC0_P (dest))
|
&& cprop_jump (BLOCK_FOR_INSN (insn), insn, NEXT_INSN (insn),
|
&& cprop_jump (BLOCK_FOR_INSN (insn), insn, NEXT_INSN (insn),
|
from, src))
|
from, src))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Handle normal insns next. */
|
/* Handle normal insns next. */
|
if (NONJUMP_INSN_P (insn) && try_replace_reg (from, src, insn))
|
if (NONJUMP_INSN_P (insn) && try_replace_reg (from, src, insn))
|
return 1;
|
return 1;
|
|
|
/* Try to propagate a CONST_INT into a conditional jump.
|
/* Try to propagate a CONST_INT into a conditional jump.
|
We're pretty specific about what we will handle in this
|
We're pretty specific about what we will handle in this
|
code, we can extend this as necessary over time.
|
code, we can extend this as necessary over time.
|
|
|
Right now the insn in question must look like
|
Right now the insn in question must look like
|
(set (pc) (if_then_else ...)) */
|
(set (pc) (if_then_else ...)) */
|
else if (any_condjump_p (insn) && onlyjump_p (insn))
|
else if (any_condjump_p (insn) && onlyjump_p (insn))
|
return cprop_jump (BLOCK_FOR_INSN (insn), NULL, insn, from, src);
|
return cprop_jump (BLOCK_FOR_INSN (insn), NULL, insn, from, src);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Perform constant and copy propagation on INSN.
|
/* Perform constant and copy propagation on INSN.
|
Return nonzero if a change was made. */
|
Return nonzero if a change was made. */
|
|
|
static int
|
static int
|
cprop_insn (rtx insn)
|
cprop_insn (rtx insn)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
int changed = 0, changed_this_round;
|
int changed = 0, changed_this_round;
|
rtx note;
|
rtx note;
|
|
|
retry:
|
retry:
|
changed_this_round = 0;
|
changed_this_round = 0;
|
reg_use_count = 0;
|
reg_use_count = 0;
|
note_uses (&PATTERN (insn), find_used_regs, NULL);
|
note_uses (&PATTERN (insn), find_used_regs, NULL);
|
|
|
/* We may win even when propagating constants into notes. */
|
/* We may win even when propagating constants into notes. */
|
note = find_reg_equal_equiv_note (insn);
|
note = find_reg_equal_equiv_note (insn);
|
if (note)
|
if (note)
|
find_used_regs (&XEXP (note, 0), NULL);
|
find_used_regs (&XEXP (note, 0), NULL);
|
|
|
for (i = 0; i < reg_use_count; i++)
|
for (i = 0; i < reg_use_count; i++)
|
{
|
{
|
rtx reg_used = reg_use_table[i];
|
rtx reg_used = reg_use_table[i];
|
unsigned int regno = REGNO (reg_used);
|
unsigned int regno = REGNO (reg_used);
|
rtx src;
|
rtx src;
|
struct expr *set;
|
struct expr *set;
|
|
|
/* If the register has already been set in this block, there's
|
/* If the register has already been set in this block, there's
|
nothing we can do. */
|
nothing we can do. */
|
if (! reg_not_set_p (reg_used, insn))
|
if (! reg_not_set_p (reg_used, insn))
|
continue;
|
continue;
|
|
|
/* Find an assignment that sets reg_used and is available
|
/* Find an assignment that sets reg_used and is available
|
at the start of the block. */
|
at the start of the block. */
|
set = find_avail_set (regno, insn);
|
set = find_avail_set (regno, insn);
|
if (! set)
|
if (! set)
|
continue;
|
continue;
|
|
|
src = set->src;
|
src = set->src;
|
|
|
/* Constant propagation. */
|
/* Constant propagation. */
|
if (cprop_constant_p (src))
|
if (cprop_constant_p (src))
|
{
|
{
|
if (constprop_register (reg_used, src, insn))
|
if (constprop_register (reg_used, src, insn))
|
{
|
{
|
changed_this_round = changed = 1;
|
changed_this_round = changed = 1;
|
global_const_prop_count++;
|
global_const_prop_count++;
|
if (dump_file != NULL)
|
if (dump_file != NULL)
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"GLOBAL CONST-PROP: Replacing reg %d in ", regno);
|
"GLOBAL CONST-PROP: Replacing reg %d in ", regno);
|
fprintf (dump_file, "insn %d with constant ",
|
fprintf (dump_file, "insn %d with constant ",
|
INSN_UID (insn));
|
INSN_UID (insn));
|
print_rtl (dump_file, src);
|
print_rtl (dump_file, src);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
if (INSN_DELETED_P (insn))
|
if (INSN_DELETED_P (insn))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
else if (REG_P (src)
|
else if (REG_P (src)
|
&& REGNO (src) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (src) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (src) != regno)
|
&& REGNO (src) != regno)
|
{
|
{
|
if (try_replace_reg (reg_used, src, insn))
|
if (try_replace_reg (reg_used, src, insn))
|
{
|
{
|
changed_this_round = changed = 1;
|
changed_this_round = changed = 1;
|
global_copy_prop_count++;
|
global_copy_prop_count++;
|
if (dump_file != NULL)
|
if (dump_file != NULL)
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"GLOBAL COPY-PROP: Replacing reg %d in insn %d",
|
"GLOBAL COPY-PROP: Replacing reg %d in insn %d",
|
regno, INSN_UID (insn));
|
regno, INSN_UID (insn));
|
fprintf (dump_file, " with reg %d\n", REGNO (src));
|
fprintf (dump_file, " with reg %d\n", REGNO (src));
|
}
|
}
|
|
|
/* The original insn setting reg_used may or may not now be
|
/* The original insn setting reg_used may or may not now be
|
deletable. We leave the deletion to DCE. */
|
deletable. We leave the deletion to DCE. */
|
/* FIXME: If it turns out that the insn isn't deletable,
|
/* FIXME: If it turns out that the insn isn't deletable,
|
then we may have unnecessarily extended register lifetimes
|
then we may have unnecessarily extended register lifetimes
|
and made things worse. */
|
and made things worse. */
|
}
|
}
|
}
|
}
|
|
|
/* If try_replace_reg simplified the insn, the regs found
|
/* If try_replace_reg simplified the insn, the regs found
|
by find_used_regs may not be valid anymore. Start over. */
|
by find_used_regs may not be valid anymore. Start over. */
|
if (changed_this_round)
|
if (changed_this_round)
|
goto retry;
|
goto retry;
|
}
|
}
|
|
|
if (changed && DEBUG_INSN_P (insn))
|
if (changed && DEBUG_INSN_P (insn))
|
return 0;
|
return 0;
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Like find_used_regs, but avoid recording uses that appear in
|
/* Like find_used_regs, but avoid recording uses that appear in
|
input-output contexts such as zero_extract or pre_dec. This
|
input-output contexts such as zero_extract or pre_dec. This
|
restricts the cases we consider to those for which local cprop
|
restricts the cases we consider to those for which local cprop
|
can legitimately make replacements. */
|
can legitimately make replacements. */
|
|
|
static void
|
static void
|
local_cprop_find_used_regs (rtx *xptr, void *data)
|
local_cprop_find_used_regs (rtx *xptr, void *data)
|
{
|
{
|
rtx x = *xptr;
|
rtx x = *xptr;
|
|
|
if (x == 0)
|
if (x == 0)
|
return;
|
return;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case ZERO_EXTRACT:
|
case ZERO_EXTRACT:
|
case SIGN_EXTRACT:
|
case SIGN_EXTRACT:
|
case STRICT_LOW_PART:
|
case STRICT_LOW_PART:
|
return;
|
return;
|
|
|
case PRE_DEC:
|
case PRE_DEC:
|
case PRE_INC:
|
case PRE_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case POST_INC:
|
case POST_INC:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
/* Can only legitimately appear this early in the context of
|
/* Can only legitimately appear this early in the context of
|
stack pushes for function arguments, but handle all of the
|
stack pushes for function arguments, but handle all of the
|
codes nonetheless. */
|
codes nonetheless. */
|
return;
|
return;
|
|
|
case SUBREG:
|
case SUBREG:
|
/* Setting a subreg of a register larger than word_mode leaves
|
/* Setting a subreg of a register larger than word_mode leaves
|
the non-written words unchanged. */
|
the non-written words unchanged. */
|
if (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) > BITS_PER_WORD)
|
if (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) > BITS_PER_WORD)
|
return;
|
return;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
find_used_regs (xptr, data);
|
find_used_regs (xptr, data);
|
}
|
}
|
|
|
/* Try to perform local const/copy propagation on X in INSN. */
|
/* Try to perform local const/copy propagation on X in INSN. */
|
|
|
static bool
|
static bool
|
do_local_cprop (rtx x, rtx insn)
|
do_local_cprop (rtx x, rtx insn)
|
{
|
{
|
rtx newreg = NULL, newcnst = NULL;
|
rtx newreg = NULL, newcnst = NULL;
|
|
|
/* Rule out USE instructions and ASM statements as we don't want to
|
/* Rule out USE instructions and ASM statements as we don't want to
|
change the hard registers mentioned. */
|
change the hard registers mentioned. */
|
if (REG_P (x)
|
if (REG_P (x)
|
&& (REGNO (x) >= FIRST_PSEUDO_REGISTER
|
&& (REGNO (x) >= FIRST_PSEUDO_REGISTER
|
|| (GET_CODE (PATTERN (insn)) != USE
|
|| (GET_CODE (PATTERN (insn)) != USE
|
&& asm_noperands (PATTERN (insn)) < 0)))
|
&& asm_noperands (PATTERN (insn)) < 0)))
|
{
|
{
|
cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
|
cselib_val *val = cselib_lookup (x, GET_MODE (x), 0, VOIDmode);
|
struct elt_loc_list *l;
|
struct elt_loc_list *l;
|
|
|
if (!val)
|
if (!val)
|
return false;
|
return false;
|
for (l = val->locs; l; l = l->next)
|
for (l = val->locs; l; l = l->next)
|
{
|
{
|
rtx this_rtx = l->loc;
|
rtx this_rtx = l->loc;
|
rtx note;
|
rtx note;
|
|
|
if (cprop_constant_p (this_rtx))
|
if (cprop_constant_p (this_rtx))
|
newcnst = this_rtx;
|
newcnst = this_rtx;
|
if (REG_P (this_rtx) && REGNO (this_rtx) >= FIRST_PSEUDO_REGISTER
|
if (REG_P (this_rtx) && REGNO (this_rtx) >= FIRST_PSEUDO_REGISTER
|
/* Don't copy propagate if it has attached REG_EQUIV note.
|
/* Don't copy propagate if it has attached REG_EQUIV note.
|
At this point this only function parameters should have
|
At this point this only function parameters should have
|
REG_EQUIV notes and if the argument slot is used somewhere
|
REG_EQUIV notes and if the argument slot is used somewhere
|
explicitly, it means address of parameter has been taken,
|
explicitly, it means address of parameter has been taken,
|
so we should not extend the lifetime of the pseudo. */
|
so we should not extend the lifetime of the pseudo. */
|
&& (!(note = find_reg_note (l->setting_insn, REG_EQUIV, NULL_RTX))
|
&& (!(note = find_reg_note (l->setting_insn, REG_EQUIV, NULL_RTX))
|
|| ! MEM_P (XEXP (note, 0))))
|
|| ! MEM_P (XEXP (note, 0))))
|
newreg = this_rtx;
|
newreg = this_rtx;
|
}
|
}
|
if (newcnst && constprop_register (x, newcnst, insn))
|
if (newcnst && constprop_register (x, newcnst, insn))
|
{
|
{
|
if (dump_file != NULL)
|
if (dump_file != NULL)
|
{
|
{
|
fprintf (dump_file, "LOCAL CONST-PROP: Replacing reg %d in ",
|
fprintf (dump_file, "LOCAL CONST-PROP: Replacing reg %d in ",
|
REGNO (x));
|
REGNO (x));
|
fprintf (dump_file, "insn %d with constant ",
|
fprintf (dump_file, "insn %d with constant ",
|
INSN_UID (insn));
|
INSN_UID (insn));
|
print_rtl (dump_file, newcnst);
|
print_rtl (dump_file, newcnst);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
local_const_prop_count++;
|
local_const_prop_count++;
|
return true;
|
return true;
|
}
|
}
|
else if (newreg && newreg != x && try_replace_reg (x, newreg, insn))
|
else if (newreg && newreg != x && try_replace_reg (x, newreg, insn))
|
{
|
{
|
if (dump_file != NULL)
|
if (dump_file != NULL)
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"LOCAL COPY-PROP: Replacing reg %d in insn %d",
|
"LOCAL COPY-PROP: Replacing reg %d in insn %d",
|
REGNO (x), INSN_UID (insn));
|
REGNO (x), INSN_UID (insn));
|
fprintf (dump_file, " with reg %d\n", REGNO (newreg));
|
fprintf (dump_file, " with reg %d\n", REGNO (newreg));
|
}
|
}
|
local_copy_prop_count++;
|
local_copy_prop_count++;
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Do local const/copy propagation (i.e. within each basic block). */
|
/* Do local const/copy propagation (i.e. within each basic block). */
|
|
|
static int
|
static int
|
local_cprop_pass (void)
|
local_cprop_pass (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
rtx insn;
|
rtx insn;
|
bool changed = false;
|
bool changed = false;
|
unsigned i;
|
unsigned i;
|
|
|
cselib_init (0);
|
cselib_init (0);
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
FOR_BB_INSNS (bb, insn)
|
FOR_BB_INSNS (bb, insn)
|
{
|
{
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
rtx note = find_reg_equal_equiv_note (insn);
|
rtx note = find_reg_equal_equiv_note (insn);
|
do
|
do
|
{
|
{
|
reg_use_count = 0;
|
reg_use_count = 0;
|
note_uses (&PATTERN (insn), local_cprop_find_used_regs,
|
note_uses (&PATTERN (insn), local_cprop_find_used_regs,
|
NULL);
|
NULL);
|
if (note)
|
if (note)
|
local_cprop_find_used_regs (&XEXP (note, 0), NULL);
|
local_cprop_find_used_regs (&XEXP (note, 0), NULL);
|
|
|
for (i = 0; i < reg_use_count; i++)
|
for (i = 0; i < reg_use_count; i++)
|
{
|
{
|
if (do_local_cprop (reg_use_table[i], insn))
|
if (do_local_cprop (reg_use_table[i], insn))
|
{
|
{
|
if (!DEBUG_INSN_P (insn))
|
if (!DEBUG_INSN_P (insn))
|
changed = true;
|
changed = true;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (INSN_DELETED_P (insn))
|
if (INSN_DELETED_P (insn))
|
break;
|
break;
|
}
|
}
|
while (i < reg_use_count);
|
while (i < reg_use_count);
|
}
|
}
|
cselib_process_insn (insn);
|
cselib_process_insn (insn);
|
}
|
}
|
|
|
/* Forget everything at the end of a basic block. */
|
/* Forget everything at the end of a basic block. */
|
cselib_clear_table ();
|
cselib_clear_table ();
|
}
|
}
|
|
|
cselib_finish ();
|
cselib_finish ();
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Similar to get_condition, only the resulting condition must be
|
/* Similar to get_condition, only the resulting condition must be
|
valid at JUMP, instead of at EARLIEST.
|
valid at JUMP, instead of at EARLIEST.
|
|
|
This differs from noce_get_condition in ifcvt.c in that we prefer not to
|
This differs from noce_get_condition in ifcvt.c in that we prefer not to
|
settle for the condition variable in the jump instruction being integral.
|
settle for the condition variable in the jump instruction being integral.
|
We prefer to be able to record the value of a user variable, rather than
|
We prefer to be able to record the value of a user variable, rather than
|
the value of a temporary used in a condition. This could be solved by
|
the value of a temporary used in a condition. This could be solved by
|
recording the value of *every* register scanned by canonicalize_condition,
|
recording the value of *every* register scanned by canonicalize_condition,
|
but this would require some code reorganization. */
|
but this would require some code reorganization. */
|
|
|
rtx
|
rtx
|
fis_get_condition (rtx jump)
|
fis_get_condition (rtx jump)
|
{
|
{
|
return get_condition (jump, NULL, false, true);
|
return get_condition (jump, NULL, false, true);
|
}
|
}
|
|
|
/* Check the comparison COND to see if we can safely form an implicit
|
/* Check the comparison COND to see if we can safely form an implicit
|
set from it. */
|
set from it. */
|
|
|
static bool
|
static bool
|
implicit_set_cond_p (const_rtx cond)
|
implicit_set_cond_p (const_rtx cond)
|
{
|
{
|
enum machine_mode mode;
|
enum machine_mode mode;
|
rtx cst;
|
rtx cst;
|
|
|
/* COND must be either an EQ or NE comparison. */
|
/* COND must be either an EQ or NE comparison. */
|
if (GET_CODE (cond) != EQ && GET_CODE (cond) != NE)
|
if (GET_CODE (cond) != EQ && GET_CODE (cond) != NE)
|
return false;
|
return false;
|
|
|
/* The first operand of COND must be a pseudo-reg. */
|
/* The first operand of COND must be a pseudo-reg. */
|
if (! REG_P (XEXP (cond, 0))
|
if (! REG_P (XEXP (cond, 0))
|
|| HARD_REGISTER_P (XEXP (cond, 0)))
|
|| HARD_REGISTER_P (XEXP (cond, 0)))
|
return false;
|
return false;
|
|
|
/* The second operand of COND must be a suitable constant. */
|
/* The second operand of COND must be a suitable constant. */
|
mode = GET_MODE (XEXP (cond, 0));
|
mode = GET_MODE (XEXP (cond, 0));
|
cst = XEXP (cond, 1);
|
cst = XEXP (cond, 1);
|
|
|
/* We can't perform this optimization if either operand might be or might
|
/* We can't perform this optimization if either operand might be or might
|
contain a signed zero. */
|
contain a signed zero. */
|
if (HONOR_SIGNED_ZEROS (mode))
|
if (HONOR_SIGNED_ZEROS (mode))
|
{
|
{
|
/* It is sufficient to check if CST is or contains a zero. We must
|
/* It is sufficient to check if CST is or contains a zero. We must
|
handle float, complex, and vector. If any subpart is a zero, then
|
handle float, complex, and vector. If any subpart is a zero, then
|
the optimization can't be performed. */
|
the optimization can't be performed. */
|
/* ??? The complex and vector checks are not implemented yet. We just
|
/* ??? The complex and vector checks are not implemented yet. We just
|
always return zero for them. */
|
always return zero for them. */
|
if (GET_CODE (cst) == CONST_DOUBLE)
|
if (GET_CODE (cst) == CONST_DOUBLE)
|
{
|
{
|
REAL_VALUE_TYPE d;
|
REAL_VALUE_TYPE d;
|
REAL_VALUE_FROM_CONST_DOUBLE (d, cst);
|
REAL_VALUE_FROM_CONST_DOUBLE (d, cst);
|
if (REAL_VALUES_EQUAL (d, dconst0))
|
if (REAL_VALUES_EQUAL (d, dconst0))
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return cprop_constant_p (cst);
|
return cprop_constant_p (cst);
|
}
|
}
|
|
|
/* Find the implicit sets of a function. An "implicit set" is a constraint
|
/* Find the implicit sets of a function. An "implicit set" is a constraint
|
on the value of a variable, implied by a conditional jump. For example,
|
on the value of a variable, implied by a conditional jump. For example,
|
following "if (x == 2)", the then branch may be optimized as though the
|
following "if (x == 2)", the then branch may be optimized as though the
|
conditional performed an "explicit set", in this example, "x = 2". This
|
conditional performed an "explicit set", in this example, "x = 2". This
|
function records the set patterns that are implicit at the start of each
|
function records the set patterns that are implicit at the start of each
|
basic block.
|
basic block.
|
|
|
If an implicit set is found but the set is implicit on a critical edge,
|
If an implicit set is found but the set is implicit on a critical edge,
|
this critical edge is split.
|
this critical edge is split.
|
|
|
Return true if the CFG was modified, false otherwise. */
|
Return true if the CFG was modified, false otherwise. */
|
|
|
static bool
|
static bool
|
find_implicit_sets (void)
|
find_implicit_sets (void)
|
{
|
{
|
basic_block bb, dest;
|
basic_block bb, dest;
|
rtx cond, new_rtx;
|
rtx cond, new_rtx;
|
unsigned int count = 0;
|
unsigned int count = 0;
|
bool edges_split = false;
|
bool edges_split = false;
|
size_t implicit_sets_size = last_basic_block + 10;
|
size_t implicit_sets_size = last_basic_block + 10;
|
|
|
implicit_sets = XCNEWVEC (rtx, implicit_sets_size);
|
implicit_sets = XCNEWVEC (rtx, implicit_sets_size);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
/* Check for more than one successor. */
|
/* Check for more than one successor. */
|
if (EDGE_COUNT (bb->succs) <= 1)
|
if (EDGE_COUNT (bb->succs) <= 1)
|
continue;
|
continue;
|
|
|
cond = fis_get_condition (BB_END (bb));
|
cond = fis_get_condition (BB_END (bb));
|
|
|
/* If no condition is found or if it isn't of a suitable form,
|
/* If no condition is found or if it isn't of a suitable form,
|
ignore it. */
|
ignore it. */
|
if (! cond || ! implicit_set_cond_p (cond))
|
if (! cond || ! implicit_set_cond_p (cond))
|
continue;
|
continue;
|
|
|
dest = GET_CODE (cond) == EQ
|
dest = GET_CODE (cond) == EQ
|
? BRANCH_EDGE (bb)->dest : FALLTHRU_EDGE (bb)->dest;
|
? BRANCH_EDGE (bb)->dest : FALLTHRU_EDGE (bb)->dest;
|
|
|
/* If DEST doesn't go anywhere, ignore it. */
|
/* If DEST doesn't go anywhere, ignore it. */
|
if (! dest || dest == EXIT_BLOCK_PTR)
|
if (! dest || dest == EXIT_BLOCK_PTR)
|
continue;
|
continue;
|
|
|
/* We have found a suitable implicit set. Try to record it now as
|
/* We have found a suitable implicit set. Try to record it now as
|
a SET in DEST. If DEST has more than one predecessor, the edge
|
a SET in DEST. If DEST has more than one predecessor, the edge
|
between BB and DEST is a critical edge and we must split it,
|
between BB and DEST is a critical edge and we must split it,
|
because we can only record one implicit set per DEST basic block. */
|
because we can only record one implicit set per DEST basic block. */
|
if (! single_pred_p (dest))
|
if (! single_pred_p (dest))
|
{
|
{
|
dest = split_edge (find_edge (bb, dest));
|
dest = split_edge (find_edge (bb, dest));
|
edges_split = true;
|
edges_split = true;
|
}
|
}
|
|
|
if (implicit_sets_size <= (size_t) dest->index)
|
if (implicit_sets_size <= (size_t) dest->index)
|
{
|
{
|
size_t old_implicit_sets_size = implicit_sets_size;
|
size_t old_implicit_sets_size = implicit_sets_size;
|
implicit_sets_size *= 2;
|
implicit_sets_size *= 2;
|
implicit_sets = XRESIZEVEC (rtx, implicit_sets, implicit_sets_size);
|
implicit_sets = XRESIZEVEC (rtx, implicit_sets, implicit_sets_size);
|
memset (implicit_sets + old_implicit_sets_size, 0,
|
memset (implicit_sets + old_implicit_sets_size, 0,
|
(implicit_sets_size - old_implicit_sets_size) * sizeof (rtx));
|
(implicit_sets_size - old_implicit_sets_size) * sizeof (rtx));
|
}
|
}
|
|
|
new_rtx = gen_rtx_SET (VOIDmode, XEXP (cond, 0),
|
new_rtx = gen_rtx_SET (VOIDmode, XEXP (cond, 0),
|
XEXP (cond, 1));
|
XEXP (cond, 1));
|
implicit_sets[dest->index] = new_rtx;
|
implicit_sets[dest->index] = new_rtx;
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf(dump_file, "Implicit set of reg %d in ",
|
fprintf(dump_file, "Implicit set of reg %d in ",
|
REGNO (XEXP (cond, 0)));
|
REGNO (XEXP (cond, 0)));
|
fprintf(dump_file, "basic block %d\n", dest->index);
|
fprintf(dump_file, "basic block %d\n", dest->index);
|
}
|
}
|
count++;
|
count++;
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Found %d implicit sets\n", count);
|
fprintf (dump_file, "Found %d implicit sets\n", count);
|
|
|
/* Confess our sins. */
|
/* Confess our sins. */
|
return edges_split;
|
return edges_split;
|
}
|
}
|
|
|
/* Bypass conditional jumps. */
|
/* Bypass conditional jumps. */
|
|
|
/* The value of last_basic_block at the beginning of the jump_bypass
|
/* The value of last_basic_block at the beginning of the jump_bypass
|
pass. The use of redirect_edge_and_branch_force may introduce new
|
pass. The use of redirect_edge_and_branch_force may introduce new
|
basic blocks, but the data flow analysis is only valid for basic
|
basic blocks, but the data flow analysis is only valid for basic
|
block indices less than bypass_last_basic_block. */
|
block indices less than bypass_last_basic_block. */
|
|
|
static int bypass_last_basic_block;
|
static int bypass_last_basic_block;
|
|
|
/* Find a set of REGNO to a constant that is available at the end of basic
|
/* Find a set of REGNO to a constant that is available at the end of basic
|
block BB. Return NULL if no such set is found. Based heavily upon
|
block BB. Return NULL if no such set is found. Based heavily upon
|
find_avail_set. */
|
find_avail_set. */
|
|
|
static struct expr *
|
static struct expr *
|
find_bypass_set (int regno, int bb)
|
find_bypass_set (int regno, int bb)
|
{
|
{
|
struct expr *result = 0;
|
struct expr *result = 0;
|
|
|
for (;;)
|
for (;;)
|
{
|
{
|
rtx src;
|
rtx src;
|
struct expr *set = lookup_set (regno, &set_hash_table);
|
struct expr *set = lookup_set (regno, &set_hash_table);
|
|
|
while (set)
|
while (set)
|
{
|
{
|
if (TEST_BIT (cprop_avout[bb], set->bitmap_index))
|
if (TEST_BIT (cprop_avout[bb], set->bitmap_index))
|
break;
|
break;
|
set = next_set (regno, set);
|
set = next_set (regno, set);
|
}
|
}
|
|
|
if (set == 0)
|
if (set == 0)
|
break;
|
break;
|
|
|
src = set->src;
|
src = set->src;
|
if (cprop_constant_p (src))
|
if (cprop_constant_p (src))
|
result = set;
|
result = set;
|
|
|
if (! REG_P (src))
|
if (! REG_P (src))
|
break;
|
break;
|
|
|
regno = REGNO (src);
|
regno = REGNO (src);
|
}
|
}
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Subroutine of bypass_block that checks whether a pseudo is killed by
|
/* Subroutine of bypass_block that checks whether a pseudo is killed by
|
any of the instructions inserted on an edge. Jump bypassing places
|
any of the instructions inserted on an edge. Jump bypassing places
|
condition code setters on CFG edges using insert_insn_on_edge. This
|
condition code setters on CFG edges using insert_insn_on_edge. This
|
function is required to check that our data flow analysis is still
|
function is required to check that our data flow analysis is still
|
valid prior to commit_edge_insertions. */
|
valid prior to commit_edge_insertions. */
|
|
|
static bool
|
static bool
|
reg_killed_on_edge (const_rtx reg, const_edge e)
|
reg_killed_on_edge (const_rtx reg, const_edge e)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
|
for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
|
if (INSN_P (insn) && reg_set_p (reg, insn))
|
if (INSN_P (insn) && reg_set_p (reg, insn))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Subroutine of bypass_conditional_jumps that attempts to bypass the given
|
/* Subroutine of bypass_conditional_jumps that attempts to bypass the given
|
basic block BB which has more than one predecessor. If not NULL, SETCC
|
basic block BB which has more than one predecessor. If not NULL, SETCC
|
is the first instruction of BB, which is immediately followed by JUMP_INSN
|
is the first instruction of BB, which is immediately followed by JUMP_INSN
|
JUMP. Otherwise, SETCC is NULL, and JUMP is the first insn of BB.
|
JUMP. Otherwise, SETCC is NULL, and JUMP is the first insn of BB.
|
Returns nonzero if a change was made.
|
Returns nonzero if a change was made.
|
|
|
During the jump bypassing pass, we may place copies of SETCC instructions
|
During the jump bypassing pass, we may place copies of SETCC instructions
|
on CFG edges. The following routine must be careful to pay attention to
|
on CFG edges. The following routine must be careful to pay attention to
|
these inserted insns when performing its transformations. */
|
these inserted insns when performing its transformations. */
|
|
|
static int
|
static int
|
bypass_block (basic_block bb, rtx setcc, rtx jump)
|
bypass_block (basic_block bb, rtx setcc, rtx jump)
|
{
|
{
|
rtx insn, note;
|
rtx insn, note;
|
edge e, edest;
|
edge e, edest;
|
int change;
|
int change;
|
int may_be_loop_header;
|
int may_be_loop_header;
|
unsigned removed_p;
|
unsigned removed_p;
|
unsigned i;
|
unsigned i;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
insn = (setcc != NULL) ? setcc : jump;
|
insn = (setcc != NULL) ? setcc : jump;
|
|
|
/* Determine set of register uses in INSN. */
|
/* Determine set of register uses in INSN. */
|
reg_use_count = 0;
|
reg_use_count = 0;
|
note_uses (&PATTERN (insn), find_used_regs, NULL);
|
note_uses (&PATTERN (insn), find_used_regs, NULL);
|
note = find_reg_equal_equiv_note (insn);
|
note = find_reg_equal_equiv_note (insn);
|
if (note)
|
if (note)
|
find_used_regs (&XEXP (note, 0), NULL);
|
find_used_regs (&XEXP (note, 0), NULL);
|
|
|
may_be_loop_header = false;
|
may_be_loop_header = false;
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
if (e->flags & EDGE_DFS_BACK)
|
if (e->flags & EDGE_DFS_BACK)
|
{
|
{
|
may_be_loop_header = true;
|
may_be_loop_header = true;
|
break;
|
break;
|
}
|
}
|
|
|
change = 0;
|
change = 0;
|
for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
|
for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
|
{
|
{
|
removed_p = 0;
|
removed_p = 0;
|
|
|
if (e->flags & EDGE_COMPLEX)
|
if (e->flags & EDGE_COMPLEX)
|
{
|
{
|
ei_next (&ei);
|
ei_next (&ei);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* We can't redirect edges from new basic blocks. */
|
/* We can't redirect edges from new basic blocks. */
|
if (e->src->index >= bypass_last_basic_block)
|
if (e->src->index >= bypass_last_basic_block)
|
{
|
{
|
ei_next (&ei);
|
ei_next (&ei);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* The irreducible loops created by redirecting of edges entering the
|
/* The irreducible loops created by redirecting of edges entering the
|
loop from outside would decrease effectiveness of some of the
|
loop from outside would decrease effectiveness of some of the
|
following optimizations, so prevent this. */
|
following optimizations, so prevent this. */
|
if (may_be_loop_header
|
if (may_be_loop_header
|
&& !(e->flags & EDGE_DFS_BACK))
|
&& !(e->flags & EDGE_DFS_BACK))
|
{
|
{
|
ei_next (&ei);
|
ei_next (&ei);
|
continue;
|
continue;
|
}
|
}
|
|
|
for (i = 0; i < reg_use_count; i++)
|
for (i = 0; i < reg_use_count; i++)
|
{
|
{
|
rtx reg_used = reg_use_table[i];
|
rtx reg_used = reg_use_table[i];
|
unsigned int regno = REGNO (reg_used);
|
unsigned int regno = REGNO (reg_used);
|
basic_block dest, old_dest;
|
basic_block dest, old_dest;
|
struct expr *set;
|
struct expr *set;
|
rtx src, new_rtx;
|
rtx src, new_rtx;
|
|
|
set = find_bypass_set (regno, e->src->index);
|
set = find_bypass_set (regno, e->src->index);
|
|
|
if (! set)
|
if (! set)
|
continue;
|
continue;
|
|
|
/* Check the data flow is valid after edge insertions. */
|
/* Check the data flow is valid after edge insertions. */
|
if (e->insns.r && reg_killed_on_edge (reg_used, e))
|
if (e->insns.r && reg_killed_on_edge (reg_used, e))
|
continue;
|
continue;
|
|
|
src = SET_SRC (pc_set (jump));
|
src = SET_SRC (pc_set (jump));
|
|
|
if (setcc != NULL)
|
if (setcc != NULL)
|
src = simplify_replace_rtx (src,
|
src = simplify_replace_rtx (src,
|
SET_DEST (PATTERN (setcc)),
|
SET_DEST (PATTERN (setcc)),
|
SET_SRC (PATTERN (setcc)));
|
SET_SRC (PATTERN (setcc)));
|
|
|
new_rtx = simplify_replace_rtx (src, reg_used, set->src);
|
new_rtx = simplify_replace_rtx (src, reg_used, set->src);
|
|
|
/* Jump bypassing may have already placed instructions on
|
/* Jump bypassing may have already placed instructions on
|
edges of the CFG. We can't bypass an outgoing edge that
|
edges of the CFG. We can't bypass an outgoing edge that
|
has instructions associated with it, as these insns won't
|
has instructions associated with it, as these insns won't
|
get executed if the incoming edge is redirected. */
|
get executed if the incoming edge is redirected. */
|
if (new_rtx == pc_rtx)
|
if (new_rtx == pc_rtx)
|
{
|
{
|
edest = FALLTHRU_EDGE (bb);
|
edest = FALLTHRU_EDGE (bb);
|
dest = edest->insns.r ? NULL : edest->dest;
|
dest = edest->insns.r ? NULL : edest->dest;
|
}
|
}
|
else if (GET_CODE (new_rtx) == LABEL_REF)
|
else if (GET_CODE (new_rtx) == LABEL_REF)
|
{
|
{
|
dest = BLOCK_FOR_INSN (XEXP (new_rtx, 0));
|
dest = BLOCK_FOR_INSN (XEXP (new_rtx, 0));
|
/* Don't bypass edges containing instructions. */
|
/* Don't bypass edges containing instructions. */
|
edest = find_edge (bb, dest);
|
edest = find_edge (bb, dest);
|
if (edest && edest->insns.r)
|
if (edest && edest->insns.r)
|
dest = NULL;
|
dest = NULL;
|
}
|
}
|
else
|
else
|
dest = NULL;
|
dest = NULL;
|
|
|
/* Avoid unification of the edge with other edges from original
|
/* Avoid unification of the edge with other edges from original
|
branch. We would end up emitting the instruction on "both"
|
branch. We would end up emitting the instruction on "both"
|
edges. */
|
edges. */
|
if (dest && setcc && !CC0_P (SET_DEST (PATTERN (setcc)))
|
if (dest && setcc && !CC0_P (SET_DEST (PATTERN (setcc)))
|
&& find_edge (e->src, dest))
|
&& find_edge (e->src, dest))
|
dest = NULL;
|
dest = NULL;
|
|
|
old_dest = e->dest;
|
old_dest = e->dest;
|
if (dest != NULL
|
if (dest != NULL
|
&& dest != old_dest
|
&& dest != old_dest
|
&& dest != EXIT_BLOCK_PTR)
|
&& dest != EXIT_BLOCK_PTR)
|
{
|
{
|
redirect_edge_and_branch_force (e, dest);
|
redirect_edge_and_branch_force (e, dest);
|
|
|
/* Copy the register setter to the redirected edge.
|
/* Copy the register setter to the redirected edge.
|
Don't copy CC0 setters, as CC0 is dead after jump. */
|
Don't copy CC0 setters, as CC0 is dead after jump. */
|
if (setcc)
|
if (setcc)
|
{
|
{
|
rtx pat = PATTERN (setcc);
|
rtx pat = PATTERN (setcc);
|
if (!CC0_P (SET_DEST (pat)))
|
if (!CC0_P (SET_DEST (pat)))
|
insert_insn_on_edge (copy_insn (pat), e);
|
insert_insn_on_edge (copy_insn (pat), e);
|
}
|
}
|
|
|
if (dump_file != NULL)
|
if (dump_file != NULL)
|
{
|
{
|
fprintf (dump_file, "JUMP-BYPASS: Proved reg %d "
|
fprintf (dump_file, "JUMP-BYPASS: Proved reg %d "
|
"in jump_insn %d equals constant ",
|
"in jump_insn %d equals constant ",
|
regno, INSN_UID (jump));
|
regno, INSN_UID (jump));
|
print_rtl (dump_file, set->src);
|
print_rtl (dump_file, set->src);
|
fprintf (dump_file, "\nBypass edge from %d->%d to %d\n",
|
fprintf (dump_file, "\nBypass edge from %d->%d to %d\n",
|
e->src->index, old_dest->index, dest->index);
|
e->src->index, old_dest->index, dest->index);
|
}
|
}
|
change = 1;
|
change = 1;
|
removed_p = 1;
|
removed_p = 1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (!removed_p)
|
if (!removed_p)
|
ei_next (&ei);
|
ei_next (&ei);
|
}
|
}
|
return change;
|
return change;
|
}
|
}
|
|
|
/* Find basic blocks with more than one predecessor that only contain a
|
/* Find basic blocks with more than one predecessor that only contain a
|
single conditional jump. If the result of the comparison is known at
|
single conditional jump. If the result of the comparison is known at
|
compile-time from any incoming edge, redirect that edge to the
|
compile-time from any incoming edge, redirect that edge to the
|
appropriate target. Return nonzero if a change was made.
|
appropriate target. Return nonzero if a change was made.
|
|
|
This function is now mis-named, because we also handle indirect jumps. */
|
This function is now mis-named, because we also handle indirect jumps. */
|
|
|
static int
|
static int
|
bypass_conditional_jumps (void)
|
bypass_conditional_jumps (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
int changed;
|
int changed;
|
rtx setcc;
|
rtx setcc;
|
rtx insn;
|
rtx insn;
|
rtx dest;
|
rtx dest;
|
|
|
/* Note we start at block 1. */
|
/* Note we start at block 1. */
|
if (ENTRY_BLOCK_PTR->next_bb == EXIT_BLOCK_PTR)
|
if (ENTRY_BLOCK_PTR->next_bb == EXIT_BLOCK_PTR)
|
return 0;
|
return 0;
|
|
|
bypass_last_basic_block = last_basic_block;
|
bypass_last_basic_block = last_basic_block;
|
mark_dfs_back_edges ();
|
mark_dfs_back_edges ();
|
|
|
changed = 0;
|
changed = 0;
|
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb->next_bb,
|
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb->next_bb,
|
EXIT_BLOCK_PTR, next_bb)
|
EXIT_BLOCK_PTR, next_bb)
|
{
|
{
|
/* Check for more than one predecessor. */
|
/* Check for more than one predecessor. */
|
if (!single_pred_p (bb))
|
if (!single_pred_p (bb))
|
{
|
{
|
setcc = NULL_RTX;
|
setcc = NULL_RTX;
|
FOR_BB_INSNS (bb, insn)
|
FOR_BB_INSNS (bb, insn)
|
if (DEBUG_INSN_P (insn))
|
if (DEBUG_INSN_P (insn))
|
continue;
|
continue;
|
else if (NONJUMP_INSN_P (insn))
|
else if (NONJUMP_INSN_P (insn))
|
{
|
{
|
if (setcc)
|
if (setcc)
|
break;
|
break;
|
if (GET_CODE (PATTERN (insn)) != SET)
|
if (GET_CODE (PATTERN (insn)) != SET)
|
break;
|
break;
|
|
|
dest = SET_DEST (PATTERN (insn));
|
dest = SET_DEST (PATTERN (insn));
|
if (REG_P (dest) || CC0_P (dest))
|
if (REG_P (dest) || CC0_P (dest))
|
setcc = insn;
|
setcc = insn;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
else if (JUMP_P (insn))
|
else if (JUMP_P (insn))
|
{
|
{
|
if ((any_condjump_p (insn) || computed_jump_p (insn))
|
if ((any_condjump_p (insn) || computed_jump_p (insn))
|
&& onlyjump_p (insn))
|
&& onlyjump_p (insn))
|
changed |= bypass_block (bb, setcc, insn);
|
changed |= bypass_block (bb, setcc, insn);
|
break;
|
break;
|
}
|
}
|
else if (INSN_P (insn))
|
else if (INSN_P (insn))
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* If we bypassed any register setting insns, we inserted a
|
/* If we bypassed any register setting insns, we inserted a
|
copy on the redirected edge. These need to be committed. */
|
copy on the redirected edge. These need to be committed. */
|
if (changed)
|
if (changed)
|
commit_edge_insertions ();
|
commit_edge_insertions ();
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Return true if the graph is too expensive to optimize. PASS is the
|
/* Return true if the graph is too expensive to optimize. PASS is the
|
optimization about to be performed. */
|
optimization about to be performed. */
|
|
|
static bool
|
static bool
|
is_too_expensive (const char *pass)
|
is_too_expensive (const char *pass)
|
{
|
{
|
/* Trying to perform global optimizations on flow graphs which have
|
/* Trying to perform global optimizations on flow graphs which have
|
a high connectivity will take a long time and is unlikely to be
|
a high connectivity will take a long time and is unlikely to be
|
particularly useful.
|
particularly useful.
|
|
|
In normal circumstances a cfg should have about twice as many
|
In normal circumstances a cfg should have about twice as many
|
edges as blocks. But we do not want to punish small functions
|
edges as blocks. But we do not want to punish small functions
|
which have a couple switch statements. Rather than simply
|
which have a couple switch statements. Rather than simply
|
threshold the number of blocks, uses something with a more
|
threshold the number of blocks, uses something with a more
|
graceful degradation. */
|
graceful degradation. */
|
if (n_edges > 20000 + n_basic_blocks * 4)
|
if (n_edges > 20000 + n_basic_blocks * 4)
|
{
|
{
|
warning (OPT_Wdisabled_optimization,
|
warning (OPT_Wdisabled_optimization,
|
"%s: %d basic blocks and %d edges/basic block",
|
"%s: %d basic blocks and %d edges/basic block",
|
pass, n_basic_blocks, n_edges / n_basic_blocks);
|
pass, n_basic_blocks, n_edges / n_basic_blocks);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* If allocating memory for the cprop bitmap would take up too much
|
/* If allocating memory for the cprop bitmap would take up too much
|
storage it's better just to disable the optimization. */
|
storage it's better just to disable the optimization. */
|
if ((n_basic_blocks
|
if ((n_basic_blocks
|
* SBITMAP_SET_SIZE (max_reg_num ())
|
* SBITMAP_SET_SIZE (max_reg_num ())
|
* sizeof (SBITMAP_ELT_TYPE)) > MAX_GCSE_MEMORY)
|
* sizeof (SBITMAP_ELT_TYPE)) > MAX_GCSE_MEMORY)
|
{
|
{
|
warning (OPT_Wdisabled_optimization,
|
warning (OPT_Wdisabled_optimization,
|
"%s: %d basic blocks and %d registers",
|
"%s: %d basic blocks and %d registers",
|
pass, n_basic_blocks, max_reg_num ());
|
pass, n_basic_blocks, max_reg_num ());
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Main function for the CPROP pass. */
|
/* Main function for the CPROP pass. */
|
|
|
static int
|
static int
|
one_cprop_pass (void)
|
one_cprop_pass (void)
|
{
|
{
|
int i;
|
int i;
|
int changed = 0;
|
int changed = 0;
|
|
|
/* Return if there's nothing to do, or it is too expensive. */
|
/* Return if there's nothing to do, or it is too expensive. */
|
if (n_basic_blocks <= NUM_FIXED_BLOCKS + 1
|
if (n_basic_blocks <= NUM_FIXED_BLOCKS + 1
|
|| is_too_expensive (_ ("const/copy propagation disabled")))
|
|| is_too_expensive (_ ("const/copy propagation disabled")))
|
return 0;
|
return 0;
|
|
|
global_const_prop_count = local_const_prop_count = 0;
|
global_const_prop_count = local_const_prop_count = 0;
|
global_copy_prop_count = local_copy_prop_count = 0;
|
global_copy_prop_count = local_copy_prop_count = 0;
|
|
|
bytes_used = 0;
|
bytes_used = 0;
|
gcc_obstack_init (&cprop_obstack);
|
gcc_obstack_init (&cprop_obstack);
|
|
|
/* Do a local const/copy propagation pass first. The global pass
|
/* Do a local const/copy propagation pass first. The global pass
|
only handles global opportunities.
|
only handles global opportunities.
|
If the local pass changes something, remove any unreachable blocks
|
If the local pass changes something, remove any unreachable blocks
|
because the CPROP global dataflow analysis may get into infinite
|
because the CPROP global dataflow analysis may get into infinite
|
loops for CFGs with unreachable blocks.
|
loops for CFGs with unreachable blocks.
|
|
|
FIXME: This local pass should not be necessary after CSE (but for
|
FIXME: This local pass should not be necessary after CSE (but for
|
some reason it still is). It is also (proven) not necessary
|
some reason it still is). It is also (proven) not necessary
|
to run the local pass right after FWPWOP.
|
to run the local pass right after FWPWOP.
|
|
|
FIXME: The global analysis would not get into infinite loops if it
|
FIXME: The global analysis would not get into infinite loops if it
|
would use the DF solver (via df_simple_dataflow) instead of
|
would use the DF solver (via df_simple_dataflow) instead of
|
the solver implemented in this file. */
|
the solver implemented in this file. */
|
changed |= local_cprop_pass ();
|
changed |= local_cprop_pass ();
|
if (changed)
|
if (changed)
|
delete_unreachable_blocks ();
|
delete_unreachable_blocks ();
|
|
|
/* Determine implicit sets. This may change the CFG (split critical
|
/* Determine implicit sets. This may change the CFG (split critical
|
edges if that exposes an implicit set).
|
edges if that exposes an implicit set).
|
Note that find_implicit_sets() does not rely on up-to-date DF caches
|
Note that find_implicit_sets() does not rely on up-to-date DF caches
|
so that we do not have to re-run df_analyze() even if local CPROP
|
so that we do not have to re-run df_analyze() even if local CPROP
|
changed something.
|
changed something.
|
??? This could run earlier so that any uncovered implicit sets
|
??? This could run earlier so that any uncovered implicit sets
|
sets could be exploited in local_cprop_pass() also. Later. */
|
sets could be exploited in local_cprop_pass() also. Later. */
|
changed |= find_implicit_sets ();
|
changed |= find_implicit_sets ();
|
|
|
/* If local_cprop_pass() or find_implicit_sets() changed something,
|
/* If local_cprop_pass() or find_implicit_sets() changed something,
|
run df_analyze() to bring all insn caches up-to-date, and to take
|
run df_analyze() to bring all insn caches up-to-date, and to take
|
new basic blocks from edge splitting on the DF radar.
|
new basic blocks from edge splitting on the DF radar.
|
NB: This also runs the fast DCE pass, because execute_rtl_cprop
|
NB: This also runs the fast DCE pass, because execute_rtl_cprop
|
sets DF_LR_RUN_DCE. */
|
sets DF_LR_RUN_DCE. */
|
if (changed)
|
if (changed)
|
df_analyze ();
|
df_analyze ();
|
|
|
/* Initialize implicit_set_indexes array. */
|
/* Initialize implicit_set_indexes array. */
|
implicit_set_indexes = XNEWVEC (int, last_basic_block);
|
implicit_set_indexes = XNEWVEC (int, last_basic_block);
|
for (i = 0; i < last_basic_block; i++)
|
for (i = 0; i < last_basic_block; i++)
|
implicit_set_indexes[i] = -1;
|
implicit_set_indexes[i] = -1;
|
|
|
alloc_hash_table (&set_hash_table);
|
alloc_hash_table (&set_hash_table);
|
compute_hash_table (&set_hash_table);
|
compute_hash_table (&set_hash_table);
|
|
|
/* Free implicit_sets before peak usage. */
|
/* Free implicit_sets before peak usage. */
|
free (implicit_sets);
|
free (implicit_sets);
|
implicit_sets = NULL;
|
implicit_sets = NULL;
|
|
|
if (dump_file)
|
if (dump_file)
|
dump_hash_table (dump_file, "SET", &set_hash_table);
|
dump_hash_table (dump_file, "SET", &set_hash_table);
|
if (set_hash_table.n_elems > 0)
|
if (set_hash_table.n_elems > 0)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
rtx insn;
|
rtx insn;
|
|
|
alloc_cprop_mem (last_basic_block, set_hash_table.n_elems);
|
alloc_cprop_mem (last_basic_block, set_hash_table.n_elems);
|
compute_cprop_data ();
|
compute_cprop_data ();
|
|
|
free (implicit_set_indexes);
|
free (implicit_set_indexes);
|
implicit_set_indexes = NULL;
|
implicit_set_indexes = NULL;
|
|
|
/* Allocate vars to track sets of regs. */
|
/* Allocate vars to track sets of regs. */
|
reg_set_bitmap = ALLOC_REG_SET (NULL);
|
reg_set_bitmap = ALLOC_REG_SET (NULL);
|
|
|
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb->next_bb, EXIT_BLOCK_PTR,
|
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb->next_bb, EXIT_BLOCK_PTR,
|
next_bb)
|
next_bb)
|
{
|
{
|
/* Reset tables used to keep track of what's still valid [since
|
/* Reset tables used to keep track of what's still valid [since
|
the start of the block]. */
|
the start of the block]. */
|
reset_opr_set_tables ();
|
reset_opr_set_tables ();
|
|
|
FOR_BB_INSNS (bb, insn)
|
FOR_BB_INSNS (bb, insn)
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
changed |= cprop_insn (insn);
|
changed |= cprop_insn (insn);
|
|
|
/* Keep track of everything modified by this insn. */
|
/* Keep track of everything modified by this insn. */
|
/* ??? Need to be careful w.r.t. mods done to INSN.
|
/* ??? Need to be careful w.r.t. mods done to INSN.
|
Don't call mark_oprs_set if we turned the
|
Don't call mark_oprs_set if we turned the
|
insn into a NOTE, or deleted the insn. */
|
insn into a NOTE, or deleted the insn. */
|
if (! NOTE_P (insn) && ! INSN_DELETED_P (insn))
|
if (! NOTE_P (insn) && ! INSN_DELETED_P (insn))
|
mark_oprs_set (insn);
|
mark_oprs_set (insn);
|
}
|
}
|
}
|
}
|
|
|
changed |= bypass_conditional_jumps ();
|
changed |= bypass_conditional_jumps ();
|
|
|
FREE_REG_SET (reg_set_bitmap);
|
FREE_REG_SET (reg_set_bitmap);
|
free_cprop_mem ();
|
free_cprop_mem ();
|
}
|
}
|
else
|
else
|
{
|
{
|
free (implicit_set_indexes);
|
free (implicit_set_indexes);
|
implicit_set_indexes = NULL;
|
implicit_set_indexes = NULL;
|
}
|
}
|
|
|
free_hash_table (&set_hash_table);
|
free_hash_table (&set_hash_table);
|
obstack_free (&cprop_obstack, NULL);
|
obstack_free (&cprop_obstack, NULL);
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "CPROP of %s, %d basic blocks, %d bytes needed, ",
|
fprintf (dump_file, "CPROP of %s, %d basic blocks, %d bytes needed, ",
|
current_function_name (), n_basic_blocks, bytes_used);
|
current_function_name (), n_basic_blocks, bytes_used);
|
fprintf (dump_file, "%d local const props, %d local copy props, ",
|
fprintf (dump_file, "%d local const props, %d local copy props, ",
|
local_const_prop_count, local_copy_prop_count);
|
local_const_prop_count, local_copy_prop_count);
|
fprintf (dump_file, "%d global const props, %d global copy props\n\n",
|
fprintf (dump_file, "%d global const props, %d global copy props\n\n",
|
global_const_prop_count, global_copy_prop_count);
|
global_const_prop_count, global_copy_prop_count);
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* All the passes implemented in this file. Each pass has its
|
/* All the passes implemented in this file. Each pass has its
|
own gate and execute function, and at the end of the file a
|
own gate and execute function, and at the end of the file a
|
pass definition for passes.c.
|
pass definition for passes.c.
|
|
|
We do not construct an accurate cfg in functions which call
|
We do not construct an accurate cfg in functions which call
|
setjmp, so none of these passes runs if the function calls
|
setjmp, so none of these passes runs if the function calls
|
setjmp.
|
setjmp.
|
FIXME: Should just handle setjmp via REG_SETJMP notes. */
|
FIXME: Should just handle setjmp via REG_SETJMP notes. */
|
|
|
static bool
|
static bool
|
gate_rtl_cprop (void)
|
gate_rtl_cprop (void)
|
{
|
{
|
return optimize > 0 && flag_gcse
|
return optimize > 0 && flag_gcse
|
&& !cfun->calls_setjmp
|
&& !cfun->calls_setjmp
|
&& dbg_cnt (cprop);
|
&& dbg_cnt (cprop);
|
}
|
}
|
|
|
static unsigned int
|
static unsigned int
|
execute_rtl_cprop (void)
|
execute_rtl_cprop (void)
|
{
|
{
|
int changed;
|
int changed;
|
delete_unreachable_blocks ();
|
delete_unreachable_blocks ();
|
df_set_flags (DF_LR_RUN_DCE);
|
df_set_flags (DF_LR_RUN_DCE);
|
df_analyze ();
|
df_analyze ();
|
changed = one_cprop_pass ();
|
changed = one_cprop_pass ();
|
flag_rerun_cse_after_global_opts |= changed;
|
flag_rerun_cse_after_global_opts |= changed;
|
if (changed)
|
if (changed)
|
cleanup_cfg (0);
|
cleanup_cfg (0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct rtl_opt_pass pass_rtl_cprop =
|
struct rtl_opt_pass pass_rtl_cprop =
|
{
|
{
|
{
|
{
|
RTL_PASS,
|
RTL_PASS,
|
"cprop", /* name */
|
"cprop", /* name */
|
gate_rtl_cprop, /* gate */
|
gate_rtl_cprop, /* gate */
|
execute_rtl_cprop, /* execute */
|
execute_rtl_cprop, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_CPROP, /* tv_id */
|
TV_CPROP, /* tv_id */
|
PROP_cfglayout, /* properties_required */
|
PROP_cfglayout, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_df_finish | TODO_verify_rtl_sharing |
|
TODO_df_finish | TODO_verify_rtl_sharing |
|
TODO_verify_flow | TODO_ggc_collect /* todo_flags_finish */
|
TODO_verify_flow | TODO_ggc_collect /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
