/* Partial redundancy elimination / Hoisting for RTL.
- Copyright (C) 1997-2014 Free Software Foundation, Inc.
+ Copyright (C) 1997-2015 Free Software Foundation, Inc.
This file is part of GCC.
#include "tm.h"
#include "diagnostic-core.h"
#include "toplev.h"
-
#include "hard-reg-set.h"
#include "rtl.h"
+#include "alias.h"
+#include "symtab.h"
#include "tree.h"
#include "tm_p.h"
#include "regs.h"
#include "flags.h"
#include "insn-config.h"
#include "recog.h"
-#include "basic-block.h"
+#include "predict.h"
#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "cfgrtl.h"
+#include "cfganal.h"
+#include "lcm.h"
+#include "cfgcleanup.h"
+#include "basic-block.h"
+#include "expmed.h"
+#include "dojump.h"
+#include "explow.h"
+#include "calls.h"
+#include "emit-rtl.h"
+#include "varasm.h"
+#include "stmt.h"
#include "expr.h"
#include "except.h"
-#include "ggc.h"
#include "params.h"
+#include "alloc-pool.h"
#include "cselib.h"
#include "intl.h"
#include "obstack.h"
#include "tree-pass.h"
-#include "hash-table.h"
#include "df.h"
#include "dbgcnt.h"
#include "target.h"
#include "gcse.h"
+#include "gcse-common.h"
/* We support GCSE via Partial Redundancy Elimination. PRE optimizations
are a superset of those done by classic GCSE.
/* Hash table of expressions. */
-struct expr
+struct gcse_expr
{
/* The expression. */
rtx expr;
/* Index in the available expression bitmaps. */
int bitmap_index;
/* Next entry with the same hash. */
- struct expr *next_same_hash;
+ struct gcse_expr *next_same_hash;
/* List of anticipatable occurrences in basic blocks in the function.
An "anticipatable occurrence" is one that is the first occurrence in the
basic block, the operands are not modified in the basic block prior
to the occurrence and the output is not used between the start of
the block and the occurrence. */
- struct occr *antic_occr;
+ struct gcse_occr *antic_occr;
/* List of available occurrence in basic blocks in the function.
An "available occurrence" is one that is the last occurrence in the
basic block and the operands are not modified by following statements in
the basic block [including this insn]. */
- struct occr *avail_occr;
+ struct gcse_occr *avail_occr;
/* Non-null if the computation is PRE redundant.
The value is the newly created pseudo-reg to record a copy of the
expression in all the places that reach the redundant copy. */
There is one per basic block. If a pattern appears more than once the
last appearance is used [or first for anticipatable expressions]. */
-struct occr
+struct gcse_occr
{
/* Next occurrence of this expression. */
- struct occr *next;
+ struct gcse_occr *next;
/* The insn that computes the expression. */
- rtx insn;
+ rtx_insn *insn;
/* Nonzero if this [anticipatable] occurrence has been deleted. */
char deleted_p;
/* Nonzero if this [available] occurrence has been copied to
char copied_p;
};
-typedef struct occr *occr_t;
+typedef struct gcse_occr *occr_t;
/* Expression hash tables.
Each hash table is an array of buckets.
[one could build a mapping table without holes afterwards though].
Someday I'll perform the computation and figure it out. */
-struct hash_table_d
+struct gcse_hash_table_d
{
/* The table itself.
This is an array of `expr_hash_table_size' elements. */
- struct expr **table;
+ struct gcse_expr **table;
/* Size of the hash table, in elements. */
unsigned int size;
};
/* Expression hash table. */
-static struct hash_table_d expr_hash_table;
+static struct gcse_hash_table_d expr_hash_table;
/* This is a list of expressions which are MEMs and will be used by load
or store motion.
struct ls_expr
{
- struct expr * expr; /* Gcse expression reference for LM. */
+ struct gcse_expr * expr; /* Gcse expression reference for LM. */
rtx pattern; /* Pattern of this mem. */
rtx pattern_regs; /* List of registers mentioned by the mem. */
- rtx loads; /* INSN list of loads seen. */
- rtx stores; /* INSN list of stores seen. */
+ rtx_insn_list *loads; /* INSN list of loads seen. */
+ rtx_insn_list *stores; /* INSN list of stores seen. */
struct ls_expr * next; /* Next in the list. */
int invalid; /* Invalid for some reason. */
int index; /* If it maps to a bitmap index. */
/* Head of the list of load/store memory refs. */
static struct ls_expr * pre_ldst_mems = NULL;
-struct pre_ldst_expr_hasher : typed_noop_remove <ls_expr>
+struct pre_ldst_expr_hasher : nofree_ptr_hash <ls_expr>
{
- typedef ls_expr value_type;
typedef value_type compare_type;
- static inline hashval_t hash (const value_type *);
- static inline bool equal (const value_type *, const compare_type *);
+ static inline hashval_t hash (const ls_expr *);
+ static inline bool equal (const ls_expr *, const ls_expr *);
};
/* Hashtable helpers. */
inline hashval_t
-pre_ldst_expr_hasher::hash (const value_type *x)
+pre_ldst_expr_hasher::hash (const ls_expr *x)
{
int do_not_record_p = 0;
return
static int expr_equiv_p (const_rtx, const_rtx);
inline bool
-pre_ldst_expr_hasher::equal (const value_type *ptr1,
- const compare_type *ptr2)
+pre_ldst_expr_hasher::equal (const ls_expr *ptr1,
+ const ls_expr *ptr2)
{
return expr_equiv_p (ptr1->pattern, ptr2->pattern);
}
/* Array, indexed by basic block number for a list of insns which modify
memory within that block. */
-static vec<rtx> *modify_mem_list;
+static vec<rtx_insn *> *modify_mem_list;
static bitmap modify_mem_list_set;
-typedef struct modify_pair_s
-{
- rtx dest; /* A MEM. */
- rtx dest_addr; /* The canonical address of `dest'. */
-} modify_pair;
-
-
/* This array parallels modify_mem_list, except that it stores MEMs
being set and their canonicalized memory addresses. */
static vec<modify_pair> *canon_modify_mem_list;
static void *gcse_alloc (unsigned long);
static void alloc_gcse_mem (void);
static void free_gcse_mem (void);
-static void hash_scan_insn (rtx, struct hash_table_d *);
-static void hash_scan_set (rtx, rtx, struct hash_table_d *);
-static void hash_scan_clobber (rtx, rtx, struct hash_table_d *);
-static void hash_scan_call (rtx, rtx, struct hash_table_d *);
+static void hash_scan_insn (rtx_insn *, struct gcse_hash_table_d *);
+static void hash_scan_set (rtx, rtx_insn *, struct gcse_hash_table_d *);
+static void hash_scan_clobber (rtx, rtx_insn *, struct gcse_hash_table_d *);
+static void hash_scan_call (rtx, rtx_insn *, struct gcse_hash_table_d *);
static int want_to_gcse_p (rtx, int *);
-static int oprs_unchanged_p (const_rtx, const_rtx, int);
-static int oprs_anticipatable_p (const_rtx, const_rtx);
-static int oprs_available_p (const_rtx, const_rtx);
-static void insert_expr_in_table (rtx, enum machine_mode, rtx, int, int, int,
- struct hash_table_d *);
-static unsigned int hash_expr (const_rtx, enum machine_mode, int *, int);
-static void record_last_reg_set_info (rtx, int);
-static void record_last_mem_set_info (rtx);
+static int oprs_unchanged_p (const_rtx, const rtx_insn *, int);
+static int oprs_anticipatable_p (const_rtx, const rtx_insn *);
+static int oprs_available_p (const_rtx, const rtx_insn *);
+static void insert_expr_in_table (rtx, machine_mode, rtx_insn *, int, int,
+ int, struct gcse_hash_table_d *);
+static unsigned int hash_expr (const_rtx, machine_mode, int *, int);
+static void record_last_reg_set_info (rtx_insn *, int);
+static void record_last_mem_set_info (rtx_insn *);
static void record_last_set_info (rtx, const_rtx, void *);
-static void compute_hash_table (struct hash_table_d *);
-static void alloc_hash_table (struct hash_table_d *);
-static void free_hash_table (struct hash_table_d *);
-static void compute_hash_table_work (struct hash_table_d *);
-static void dump_hash_table (FILE *, const char *, struct hash_table_d *);
-static void compute_transp (const_rtx, int, sbitmap *);
+static void compute_hash_table (struct gcse_hash_table_d *);
+static void alloc_hash_table (struct gcse_hash_table_d *);
+static void free_hash_table (struct gcse_hash_table_d *);
+static void compute_hash_table_work (struct gcse_hash_table_d *);
+static void dump_hash_table (FILE *, const char *, struct gcse_hash_table_d *);
static void compute_local_properties (sbitmap *, sbitmap *, sbitmap *,
- struct hash_table_d *);
+ struct gcse_hash_table_d *);
static void mems_conflict_for_gcse_p (rtx, const_rtx, void *);
static int load_killed_in_block_p (const_basic_block, int, const_rtx, int);
-static void canon_list_insert (rtx, const_rtx, void *);
static void alloc_pre_mem (int, int);
static void free_pre_mem (void);
static struct edge_list *compute_pre_data (void);
-static int pre_expr_reaches_here_p (basic_block, struct expr *,
+static int pre_expr_reaches_here_p (basic_block, struct gcse_expr *,
basic_block);
-static void insert_insn_end_basic_block (struct expr *, basic_block);
-static void pre_insert_copy_insn (struct expr *, rtx);
+static void insert_insn_end_basic_block (struct gcse_expr *, basic_block);
+static void pre_insert_copy_insn (struct gcse_expr *, rtx_insn *);
static void pre_insert_copies (void);
static int pre_delete (void);
static int pre_gcse (struct edge_list *);
static int one_pre_gcse_pass (void);
-static void add_label_notes (rtx, rtx);
+static void add_label_notes (rtx, rtx_insn *);
static void alloc_code_hoist_mem (int, int);
static void free_code_hoist_mem (void);
static void compute_code_hoist_vbeinout (void);
static void compute_code_hoist_data (void);
-static int should_hoist_expr_to_dom (basic_block, struct expr *, basic_block,
+static int should_hoist_expr_to_dom (basic_block, struct gcse_expr *, basic_block,
sbitmap, int, int *, enum reg_class,
- int *, bitmap, rtx);
+ int *, bitmap, rtx_insn *);
static int hoist_code (void);
static enum reg_class get_regno_pressure_class (int regno, int *nregs);
-static enum reg_class get_pressure_class_and_nregs (rtx insn, int *nregs);
+static enum reg_class get_pressure_class_and_nregs (rtx_insn *insn, int *nregs);
static int one_code_hoisting_pass (void);
-static rtx process_insert_insn (struct expr *);
-static int pre_edge_insert (struct edge_list *, struct expr **);
-static int pre_expr_reaches_here_p_work (basic_block, struct expr *,
+static rtx_insn *process_insert_insn (struct gcse_expr *);
+static int pre_edge_insert (struct edge_list *, struct gcse_expr **);
+static int pre_expr_reaches_here_p_work (basic_block, struct gcse_expr *,
basic_block, char *);
static struct ls_expr * ldst_entry (rtx);
static void free_ldst_entry (struct ls_expr *);
static void invalidate_any_buried_refs (rtx);
static void compute_ld_motion_mems (void);
static void trim_ld_motion_mems (void);
-static void update_ld_motion_stores (struct expr *);
+static void update_ld_motion_stores (struct gcse_expr *);
static void clear_modify_mem_tables (void);
static void free_modify_mem_tables (void);
-static rtx gcse_emit_move_after (rtx, rtx, rtx);
static bool is_too_expensive (const char *);
#define GNEW(T) ((T *) gmalloc (sizeof (T)))
{
int i;
#ifndef AVOID_CCMODE_COPIES
- rtx reg, insn;
+ rtx reg;
+ rtx_insn *insn;
#endif
memset (can_copy, 0, NUM_MACHINE_MODES);
#ifdef AVOID_CCMODE_COPIES
can_copy[i] = 0;
#else
- reg = gen_rtx_REG ((enum machine_mode) i, LAST_VIRTUAL_REGISTER + 1);
- insn = emit_insn (gen_rtx_SET (VOIDmode, reg, reg));
+ reg = gen_rtx_REG ((machine_mode) i, LAST_VIRTUAL_REGISTER + 1);
+ insn = emit_insn (gen_rtx_SET (reg, reg));
if (recog (PATTERN (insn), insn, NULL) >= 0)
can_copy[i] = 1;
#endif
/* Returns whether the mode supports reg/reg copy operations. */
bool
-can_copy_p (enum machine_mode mode)
+can_copy_p (machine_mode mode)
{
if (! can_copy_init_p)
{
/* Allocate array to keep a list of insns which modify memory in each
basic block. The two typedefs are needed to work around the
pre-processor limitation with template types in macro arguments. */
- typedef vec<rtx> vec_rtx_heap;
+ typedef vec<rtx_insn *> vec_rtx_heap;
typedef vec<modify_pair> vec_modify_pair_heap;
modify_mem_list = GCNEWVEC (vec_rtx_heap, last_basic_block_for_fn (cfun));
canon_modify_mem_list = GCNEWVEC (vec_modify_pair_heap,
static void
compute_local_properties (sbitmap *transp, sbitmap *comp, sbitmap *antloc,
- struct hash_table_d *table)
+ struct gcse_hash_table_d *table)
{
unsigned int i;
for (i = 0; i < table->size; i++)
{
- struct expr *expr;
+ struct gcse_expr *expr;
for (expr = table->table[i]; expr != NULL; expr = expr->next_same_hash)
{
int indx = expr->bitmap_index;
- struct occr *occr;
+ struct gcse_occr *occr;
/* The expression is transparent in this block if it is not killed.
We start by assuming all are transparent [none are killed], and
then reset the bits for those that are. */
if (transp)
- compute_transp (expr->expr, indx, transp);
+ compute_transp (expr->expr, indx, transp,
+ blocks_with_calls,
+ modify_mem_list_set,
+ canon_modify_mem_list);
/* The occurrences recorded in antic_occr are exactly those that
we want to set to nonzero in ANTLOC. */
/* Used internally by can_assign_to_reg_without_clobbers_p. */
-static GTY(()) rtx test_insn;
+static GTY(()) rtx_insn *test_insn;
/* Return true if we can assign X to a pseudo register such that the
resulting insn does not result in clobbering a hard register as a
if (test_insn == 0)
{
test_insn
- = make_insn_raw (gen_rtx_SET (VOIDmode,
- gen_rtx_REG (word_mode,
+ = make_insn_raw (gen_rtx_SET (gen_rtx_REG (word_mode,
FIRST_PSEUDO_REGISTER * 2),
const0_rtx));
SET_NEXT_INSN (test_insn) = SET_PREV_INSN (test_insn) = 0;
or from INSN to the end of INSN's basic block (if AVAIL_P != 0). */
static int
-oprs_unchanged_p (const_rtx x, const_rtx insn, int avail_p)
+oprs_unchanged_p (const_rtx x, const rtx_insn *insn, int avail_p)
{
int i, j;
enum rtx_code code;
load_killed_in_block_p (const_basic_block bb, int uid_limit, const_rtx x,
int avail_p)
{
- vec<rtx> list = modify_mem_list[bb->index];
- rtx setter;
+ vec<rtx_insn *> list = modify_mem_list[bb->index];
+ rtx_insn *setter;
unsigned ix;
/* If this is a readonly then we aren't going to be changing it. */
the start of INSN's basic block up to but not including INSN. */
static int
-oprs_anticipatable_p (const_rtx x, const_rtx insn)
+oprs_anticipatable_p (const_rtx x, const rtx_insn *insn)
{
return oprs_unchanged_p (x, insn, 0);
}
INSN to the end of INSN's basic block. */
static int
-oprs_available_p (const_rtx x, const_rtx insn)
+oprs_available_p (const_rtx x, const rtx_insn *insn)
{
return oprs_unchanged_p (x, insn, 1);
}
the current size of the hash table to be probed. */
static unsigned int
-hash_expr (const_rtx x, enum machine_mode mode, int *do_not_record_p,
+hash_expr (const_rtx x, machine_mode mode, int *do_not_record_p,
int hash_table_size)
{
unsigned int hash;
be moved. */
static void
-insert_expr_in_table (rtx x, enum machine_mode mode, rtx insn, int antic_p,
- int avail_p, int max_distance, struct hash_table_d *table)
+insert_expr_in_table (rtx x, machine_mode mode, rtx_insn *insn,
+ int antic_p,
+ int avail_p, int max_distance, struct gcse_hash_table_d *table)
{
int found, do_not_record_p;
unsigned int hash;
- struct expr *cur_expr, *last_expr = NULL;
- struct occr *antic_occr, *avail_occr;
+ struct gcse_expr *cur_expr, *last_expr = NULL;
+ struct gcse_occr *antic_occr, *avail_occr;
hash = hash_expr (x, mode, &do_not_record_p, table->size);
if (! found)
{
- cur_expr = GOBNEW (struct expr);
- bytes_used += sizeof (struct expr);
+ cur_expr = GOBNEW (struct gcse_expr);
+ bytes_used += sizeof (struct gcse_expr);
if (table->table[hash] == NULL)
/* This is the first pattern that hashed to this index. */
table->table[hash] = cur_expr;
else
{
/* First occurrence of this expression in this basic block. */
- antic_occr = GOBNEW (struct occr);
- bytes_used += sizeof (struct occr);
+ antic_occr = GOBNEW (struct gcse_occr);
+ bytes_used += sizeof (struct gcse_occr);
antic_occr->insn = insn;
antic_occr->next = cur_expr->antic_occr;
antic_occr->deleted_p = 0;
else
{
/* First occurrence of this expression in this basic block. */
- avail_occr = GOBNEW (struct occr);
- bytes_used += sizeof (struct occr);
+ avail_occr = GOBNEW (struct gcse_occr);
+ bytes_used += sizeof (struct gcse_occr);
avail_occr->insn = insn;
avail_occr->next = cur_expr->avail_occr;
avail_occr->deleted_p = 0;
/* Scan SET present in INSN and add an entry to the hash TABLE. */
static void
-hash_scan_set (rtx set, rtx insn, struct hash_table_d *table)
+hash_scan_set (rtx set, rtx_insn *insn, struct gcse_hash_table_d *table)
{
rtx src = SET_SRC (set);
rtx dest = SET_DEST (set);
&& REG_NOTE_KIND (note) == REG_EQUAL
&& !REG_P (src)
&& want_to_gcse_p (XEXP (note, 0), NULL))
- src = XEXP (note, 0), set = gen_rtx_SET (VOIDmode, dest, src);
+ src = XEXP (note, 0), set = gen_rtx_SET (dest, src);
/* Only record sets of pseudo-regs in the hash table. */
if (regno >= FIRST_PSEUDO_REGISTER
}
static void
-hash_scan_clobber (rtx x ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED,
- struct hash_table_d *table ATTRIBUTE_UNUSED)
+hash_scan_clobber (rtx x ATTRIBUTE_UNUSED, rtx_insn *insn ATTRIBUTE_UNUSED,
+ struct gcse_hash_table_d *table ATTRIBUTE_UNUSED)
{
/* Currently nothing to do. */
}
static void
-hash_scan_call (rtx x ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED,
- struct hash_table_d *table ATTRIBUTE_UNUSED)
+hash_scan_call (rtx x ATTRIBUTE_UNUSED, rtx_insn *insn ATTRIBUTE_UNUSED,
+ struct gcse_hash_table_d *table ATTRIBUTE_UNUSED)
{
/* Currently nothing to do. */
}
/* Process INSN and add hash table entries as appropriate. */
static void
-hash_scan_insn (rtx insn, struct hash_table_d *table)
+hash_scan_insn (rtx_insn *insn, struct gcse_hash_table_d *table)
{
rtx pat = PATTERN (insn);
int i;
/* Dump the hash table TABLE to file FILE under the name NAME. */
static void
-dump_hash_table (FILE *file, const char *name, struct hash_table_d *table)
+dump_hash_table (FILE *file, const char *name, struct gcse_hash_table_d *table)
{
int i;
/* Flattened out table, so it's printed in proper order. */
- struct expr **flat_table;
+ struct gcse_expr **flat_table;
unsigned int *hash_val;
- struct expr *expr;
+ struct gcse_expr *expr;
- flat_table = XCNEWVEC (struct expr *, table->n_elems);
+ flat_table = XCNEWVEC (struct gcse_expr *, table->n_elems);
hash_val = XNEWVEC (unsigned int, table->n_elems);
for (i = 0; i < (int) table->size; i++)
valid, as a quick test to invalidate them. */
static void
-record_last_reg_set_info (rtx insn, int regno)
+record_last_reg_set_info (rtx_insn *insn, int regno)
{
struct reg_avail_info *info = ®_avail_info[regno];
int luid = DF_INSN_LUID (insn);
}
}
-/* Record all of the canonicalized MEMs of record_last_mem_set_info's insn.
- Note we store a pair of elements in the list, so they have to be
- taken off pairwise. */
-
-static void
-canon_list_insert (rtx dest ATTRIBUTE_UNUSED, const_rtx x ATTRIBUTE_UNUSED,
- void * v_insn)
-{
- rtx dest_addr, insn;
- int bb;
- modify_pair pair;
-
- while (GET_CODE (dest) == SUBREG
- || GET_CODE (dest) == ZERO_EXTRACT
- || GET_CODE (dest) == STRICT_LOW_PART)
- dest = XEXP (dest, 0);
-
- /* If DEST is not a MEM, then it will not conflict with a load. Note
- that function calls are assumed to clobber memory, but are handled
- elsewhere. */
-
- if (! MEM_P (dest))
- return;
-
- dest_addr = get_addr (XEXP (dest, 0));
- dest_addr = canon_rtx (dest_addr);
- insn = (rtx) v_insn;
- bb = BLOCK_FOR_INSN (insn)->index;
-
- pair.dest = dest;
- pair.dest_addr = dest_addr;
- canon_modify_mem_list[bb].safe_push (pair);
-}
-
/* Record memory modification information for INSN. We do not actually care
about the memory location(s) that are set, or even how they are set (consider
a CALL_INSN). We merely need to record which insns modify memory. */
static void
-record_last_mem_set_info (rtx insn)
+record_last_mem_set_info (rtx_insn *insn)
{
- int bb;
-
if (! flag_gcse_lm)
return;
- /* load_killed_in_block_p will handle the case of calls clobbering
- everything. */
- bb = BLOCK_FOR_INSN (insn)->index;
- modify_mem_list[bb].safe_push (insn);
- bitmap_set_bit (modify_mem_list_set, bb);
-
- if (CALL_P (insn))
- bitmap_set_bit (blocks_with_calls, bb);
- else
- note_stores (PATTERN (insn), canon_list_insert, (void*) insn);
+ record_last_mem_set_info_common (insn, modify_mem_list,
+ canon_modify_mem_list,
+ modify_mem_list_set,
+ blocks_with_calls);
}
/* Called from compute_hash_table via note_stores to handle one
static void
record_last_set_info (rtx dest, const_rtx setter ATTRIBUTE_UNUSED, void *data)
{
- rtx last_set_insn = (rtx) data;
+ rtx_insn *last_set_insn = (rtx_insn *) data;
if (GET_CODE (dest) == SUBREG)
dest = SUBREG_REG (dest);
TABLE is the table computed. */
static void
-compute_hash_table_work (struct hash_table_d *table)
+compute_hash_table_work (struct gcse_hash_table_d *table)
{
int i;
FOR_EACH_BB_FN (current_bb, cfun)
{
- rtx insn;
+ rtx_insn *insn;
unsigned int regno;
/* First pass over the instructions records information used to
It is used to determine the number of buckets to use. */
static void
-alloc_hash_table (struct hash_table_d *table)
+alloc_hash_table (struct gcse_hash_table_d *table)
{
int n;
Making it an odd number is simplest for now.
??? Later take some measurements. */
table->size |= 1;
- n = table->size * sizeof (struct expr *);
- table->table = GNEWVAR (struct expr *, n);
+ n = table->size * sizeof (struct gcse_expr *);
+ table->table = GNEWVAR (struct gcse_expr *, n);
}
/* Free things allocated by alloc_hash_table. */
static void
-free_hash_table (struct hash_table_d *table)
+free_hash_table (struct gcse_hash_table_d *table)
{
free (table->table);
}
/* Compute the expression hash table TABLE. */
static void
-compute_hash_table (struct hash_table_d *table)
+compute_hash_table (struct gcse_hash_table_d *table)
{
/* Initialize count of number of entries in hash table. */
table->n_elems = 0;
- memset (table->table, 0, table->size * sizeof (struct expr *));
+ memset (table->table, 0, table->size * sizeof (struct gcse_expr *));
compute_hash_table_work (table);
}
canon_modify_mem_list = 0;
}
\f
-/* For each block, compute whether X is transparent. X is either an
- expression or an assignment [though we don't care which, for this context
- an assignment is treated as an expression]. For each block where an
- element of X is modified, reset the INDX bit in BMAP. */
-
-static void
-compute_transp (const_rtx x, int indx, sbitmap *bmap)
-{
- int i, j;
- enum rtx_code code;
- const char *fmt;
-
- /* repeat is used to turn tail-recursion into iteration since GCC
- can't do it when there's no return value. */
- repeat:
-
- if (x == 0)
- return;
-
- code = GET_CODE (x);
- switch (code)
- {
- case REG:
- {
- df_ref def;
- for (def = DF_REG_DEF_CHAIN (REGNO (x));
- def;
- def = DF_REF_NEXT_REG (def))
- bitmap_clear_bit (bmap[DF_REF_BB (def)->index], indx);
- }
-
- return;
-
- case MEM:
- if (! MEM_READONLY_P (x))
- {
- bitmap_iterator bi;
- unsigned bb_index;
- rtx x_addr;
-
- x_addr = get_addr (XEXP (x, 0));
- x_addr = canon_rtx (x_addr);
-
- /* First handle all the blocks with calls. We don't need to
- do any list walking for them. */
- EXECUTE_IF_SET_IN_BITMAP (blocks_with_calls, 0, bb_index, bi)
- {
- bitmap_clear_bit (bmap[bb_index], indx);
- }
-
- /* Now iterate over the blocks which have memory modifications
- but which do not have any calls. */
- EXECUTE_IF_AND_COMPL_IN_BITMAP (modify_mem_list_set,
- blocks_with_calls,
- 0, bb_index, bi)
- {
- vec<modify_pair> list
- = canon_modify_mem_list[bb_index];
- modify_pair *pair;
- unsigned ix;
-
- FOR_EACH_VEC_ELT_REVERSE (list, ix, pair)
- {
- rtx dest = pair->dest;
- rtx dest_addr = pair->dest_addr;
-
- if (canon_true_dependence (dest, GET_MODE (dest),
- dest_addr, x, x_addr))
- {
- bitmap_clear_bit (bmap[bb_index], indx);
- break;
- }
- }
- }
- }
-
- x = XEXP (x, 0);
- goto repeat;
-
- case PC:
- case CC0: /*FIXME*/
- case CONST:
- CASE_CONST_ANY:
- case SYMBOL_REF:
- case LABEL_REF:
- case ADDR_VEC:
- case ADDR_DIFF_VEC:
- return;
-
- default:
- break;
- }
-
- for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
- {
- if (fmt[i] == 'e')
- {
- /* If we are about to do the last recursive call
- needed at this level, change it into iteration.
- This function is called enough to be worth it. */
- if (i == 0)
- {
- x = XEXP (x, i);
- goto repeat;
- }
-
- compute_transp (XEXP (x, i), indx, bmap);
- }
- else if (fmt[i] == 'E')
- for (j = 0; j < XVECLEN (x, i); j++)
- compute_transp (XVECEXP (x, i, j), indx, bmap);
- }
-}
-\f
/* Compute PRE+LCM working variables. */
/* Local properties of expressions. */
prune_expressions (bool pre_p)
{
sbitmap prune_exprs;
- struct expr *expr;
+ struct gcse_expr *expr;
unsigned int ui;
basic_block bb;
the closest such expression. */
static int
-pre_expr_reaches_here_p_work (basic_block occr_bb, struct expr *expr,
+pre_expr_reaches_here_p_work (basic_block occr_bb, struct gcse_expr *expr,
basic_block bb, char *visited)
{
edge pred;
memory allocated for that function is returned. */
static int
-pre_expr_reaches_here_p (basic_block occr_bb, struct expr *expr, basic_block bb)
+pre_expr_reaches_here_p (basic_block occr_bb, struct gcse_expr *expr, basic_block bb)
{
int rval;
char *visited = XCNEWVEC (char, last_basic_block_for_fn (cfun));
\f
/* Generate RTL to copy an EXPR to its `reaching_reg' and return it. */
-static rtx
-process_insert_insn (struct expr *expr)
+static rtx_insn *
+process_insert_insn (struct gcse_expr *expr)
{
rtx reg = expr->reaching_reg;
/* Copy the expression to make sure we don't have any sharing issues. */
rtx exp = copy_rtx (expr->expr);
- rtx pat;
+ rtx_insn *pat;
start_sequence ();
insn will be recognized (this also adds any needed CLOBBERs). */
else
{
- rtx insn = emit_insn (gen_rtx_SET (VOIDmode, reg, exp));
+ rtx_insn *insn = emit_insn (gen_rtx_SET (reg, exp));
if (insn_invalid_p (insn, false))
gcc_unreachable ();
This is used by both the PRE and code hoisting. */
static void
-insert_insn_end_basic_block (struct expr *expr, basic_block bb)
+insert_insn_end_basic_block (struct gcse_expr *expr, basic_block bb)
{
- rtx insn = BB_END (bb);
- rtx new_insn;
+ rtx_insn *insn = BB_END (bb);
+ rtx_insn *new_insn;
rtx reg = expr->reaching_reg;
int regno = REGNO (reg);
- rtx pat, pat_end;
+ rtx_insn *pat, *pat_end;
pat = process_insert_insn (expr);
gcc_assert (pat && INSN_P (pat));
&& (!single_succ_p (bb)
|| single_succ_edge (bb)->flags & EDGE_ABNORMAL)))
{
-#ifdef HAVE_cc0
/* FIXME: 'twould be nice to call prev_cc0_setter here but it aborts
if cc0 isn't set. */
- rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
- if (note)
- insn = XEXP (note, 0);
- else
+ if (HAVE_cc0)
{
- rtx maybe_cc0_setter = prev_nonnote_insn (insn);
- if (maybe_cc0_setter
- && INSN_P (maybe_cc0_setter)
- && sets_cc0_p (PATTERN (maybe_cc0_setter)))
- insn = maybe_cc0_setter;
+ rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
+ if (note)
+ insn = safe_as_a <rtx_insn *> (XEXP (note, 0));
+ else
+ {
+ rtx_insn *maybe_cc0_setter = prev_nonnote_insn (insn);
+ if (maybe_cc0_setter
+ && INSN_P (maybe_cc0_setter)
+ && sets_cc0_p (PATTERN (maybe_cc0_setter)))
+ insn = maybe_cc0_setter;
+ }
}
-#endif
+
/* FIXME: What if something in cc0/jump uses value set in new insn? */
new_insn = emit_insn_before_noloc (pat, insn, bb);
}
the expressions fully redundant. */
static int
-pre_edge_insert (struct edge_list *edge_list, struct expr **index_map)
+pre_edge_insert (struct edge_list *edge_list, struct gcse_expr **index_map)
{
int e, i, j, num_edges, set_size, did_insert = 0;
sbitmap *inserted;
j++, insert >>= 1)
if ((insert & 1) != 0 && index_map[j]->reaching_reg != NULL_RTX)
{
- struct expr *expr = index_map[j];
- struct occr *occr;
+ struct gcse_expr *expr = index_map[j];
+ struct gcse_occr *occr;
/* Now look at each deleted occurrence of this expression. */
for (occr = expr->antic_occr; occr != NULL; occr = occr->next)
reach the deleted occurrence in BB. */
if (!bitmap_bit_p (inserted[e], j))
{
- rtx insn;
+ rtx_insn *insn;
edge eg = INDEX_EDGE (edge_list, e);
/* We can't insert anything on an abnormal and
MEM <- reaching_reg. */
static void
-pre_insert_copy_insn (struct expr *expr, rtx insn)
+pre_insert_copy_insn (struct gcse_expr *expr, rtx_insn *insn)
{
rtx reg = expr->reaching_reg;
int regno = REGNO (reg);
int indx = expr->bitmap_index;
rtx pat = PATTERN (insn);
- rtx set, first_set, new_insn;
+ rtx set, first_set;
+ rtx_insn *new_insn;
rtx old_reg;
int i;
pre_insert_copies (void)
{
unsigned int i, added_copy;
- struct expr *expr;
- struct occr *occr;
- struct occr *avail;
+ struct gcse_expr *expr;
+ struct gcse_occr *occr;
+ struct gcse_occr *avail;
/* For each available expression in the table, copy the result to
`reaching_reg' if the expression reaches a deleted one.
for (avail = expr->avail_occr; avail != NULL; avail = avail->next)
{
- rtx insn = avail->insn;
+ rtx_insn *insn = avail->insn;
/* No need to handle this one if handled already. */
if (avail->copied_p)
continue;
/* Don't handle this one if it's a redundant one. */
- if (INSN_DELETED_P (insn))
+ if (insn->deleted ())
continue;
/* Or if the expression doesn't reach the deleted one. */
struct set_data
{
- rtx insn;
+ rtx_insn *insn;
const_rtx set;
int nsets;
};
}
static const_rtx
-single_set_gcse (rtx insn)
+single_set_gcse (rtx_insn *insn)
{
struct set_data s;
rtx pattern;
/* Emit move from SRC to DEST noting the equivalence with expression computed
in INSN. */
-static rtx
-gcse_emit_move_after (rtx dest, rtx src, rtx insn)
+static rtx_insn *
+gcse_emit_move_after (rtx dest, rtx src, rtx_insn *insn)
{
- rtx new_rtx;
+ rtx_insn *new_rtx;
const_rtx set = single_set_gcse (insn);
rtx set2;
rtx note;
{
unsigned int i;
int changed;
- struct expr *expr;
- struct occr *occr;
+ struct gcse_expr *expr;
+ struct gcse_occr *occr;
changed = 0;
for (i = 0; i < expr_hash_table.size; i++)
/* We only need to search antic_occr since we require ANTLOC != 0. */
for (occr = expr->antic_occr; occr != NULL; occr = occr->next)
{
- rtx insn = occr->insn;
+ rtx_insn *insn = occr->insn;
rtx set;
basic_block bb = BLOCK_FOR_INSN (insn);
{
unsigned int i;
int did_insert, changed;
- struct expr **index_map;
- struct expr *expr;
+ struct gcse_expr **index_map;
+ struct gcse_expr *expr;
/* Compute a mapping from expression number (`bitmap_index') to
hash table entry. */
- index_map = XCNEWVEC (struct expr *, expr_hash_table.n_elems);
+ index_map = XCNEWVEC (struct gcse_expr *, expr_hash_table.n_elems);
for (i = 0; i < expr_hash_table.size; i++)
for (expr = expr_hash_table.table[i]; expr; expr = expr->next_same_hash)
index_map[expr->bitmap_index] = expr;
necessary REG_LABEL_OPERAND and REG_LABEL_TARGET notes. */
static void
-add_label_notes (rtx x, rtx insn)
+add_label_notes (rtx x, rtx_insn *insn)
{
enum rtx_code code = GET_CODE (x);
int i, j;
such a LABEL_REF, so we don't have to handle REG_LABEL_TARGET
notes. */
gcc_assert (!JUMP_P (insn));
- add_reg_note (insn, REG_LABEL_OPERAND, XEXP (x, 0));
+ add_reg_note (insn, REG_LABEL_OPERAND, LABEL_REF_LABEL (x));
- if (LABEL_P (XEXP (x, 0)))
- LABEL_NUSES (XEXP (x, 0))++;
+ if (LABEL_P (LABEL_REF_LABEL (x)))
+ LABEL_NUSES (LABEL_REF_LABEL (x))++;
return;
}
NOTE: Register pressure won't be increased in this function. */
static int
-update_bb_reg_pressure (basic_block bb, rtx from)
+update_bb_reg_pressure (basic_block bb, rtx_insn *from)
{
- rtx dreg, insn;
+ rtx dreg;
+ rtx_insn *insn;
basic_block succ_bb;
df_ref use, op_ref;
edge succ;
paths. */
static int
-should_hoist_expr_to_dom (basic_block expr_bb, struct expr *expr,
+should_hoist_expr_to_dom (basic_block expr_bb, struct gcse_expr *expr,
basic_block bb, sbitmap visited, int distance,
int *bb_size, enum reg_class pressure_class,
- int *nregs, bitmap hoisted_bbs, rtx from)
+ int *nregs, bitmap hoisted_bbs, rtx_insn *from)
{
unsigned int i;
edge pred;
\f
/* Find occurrence in BB. */
-static struct occr *
-find_occr_in_bb (struct occr *occr, basic_block bb)
+static struct gcse_occr *
+find_occr_in_bb (struct gcse_occr *occr, basic_block bb)
{
/* Find the right occurrence of this expression. */
while (occr && BLOCK_FOR_INSN (occr->insn) != bb)
unsigned int dom_tree_walk_index;
vec<basic_block> domby;
unsigned int i, j, k;
- struct expr **index_map;
- struct expr *expr;
+ struct gcse_expr **index_map;
+ struct gcse_expr *expr;
int *to_bb_head;
int *bb_size;
int changed = 0;
/* Compute a mapping from expression number (`bitmap_index') to
hash table entry. */
- index_map = XCNEWVEC (struct expr *, expr_hash_table.n_elems);
+ index_map = XCNEWVEC (struct gcse_expr *, expr_hash_table.n_elems);
for (i = 0; i < expr_hash_table.size; i++)
for (expr = expr_hash_table.table[i]; expr; expr = expr->next_same_hash)
index_map[expr->bitmap_index] = expr;
FOR_EACH_BB_FN (bb, cfun)
{
- rtx insn;
+ rtx_insn *insn;
int to_head;
to_head = 0;
int nregs = 0;
enum reg_class pressure_class = NO_REGS;
/* Current expression. */
- struct expr *expr = index_map[i];
+ struct gcse_expr *expr = index_map[i];
/* Number of occurrences of EXPR that can be hoisted to BB. */
int hoistable = 0;
/* Occurrences reachable from BB. */
to hoist to BB and make the transformations. */
FOR_EACH_VEC_ELT (occrs_to_hoist, j, occr)
{
- rtx insn;
+ rtx_insn *insn;
const_rtx set;
gcc_assert (!occr->deleted_p);
/* Return pressure class and number of hard registers (through *NREGS)
for destination of INSN. */
static enum reg_class
-get_pressure_class_and_nregs (rtx insn, int *nregs)
+get_pressure_class_and_nregs (rtx_insn *insn, int *nregs)
{
rtx reg;
enum reg_class pressure_class;
{
int i;
unsigned int j;
- rtx insn;
+ rtx_insn *insn;
basic_block bb;
bitmap curr_regs_live;
bitmap_iterator bi;
ptr->expr = NULL;
ptr->pattern = x;
ptr->pattern_regs = NULL_RTX;
- ptr->loads = NULL_RTX;
- ptr->stores = NULL_RTX;
+ ptr->loads = NULL;
+ ptr->stores = NULL;
ptr->reaching_reg = NULL_RTX;
ptr->invalid = 0;
ptr->index = 0;
{
struct ls_expr * ptr;
basic_block bb;
- rtx insn;
+ rtx_insn *insn;
pre_ldst_mems = NULL;
pre_ldst_table = new hash_table<pre_ldst_expr_hasher> (13);
while (ptr != NULL)
{
- struct expr * expr;
+ struct gcse_expr * expr;
/* Delete if entry has been made invalid. */
if (! ptr->invalid)
break;
}
else
- expr = (struct expr *) 0;
+ expr = (struct gcse_expr *) 0;
if (expr)
{
correct value in the reaching register for the loads. */
static void
-update_ld_motion_stores (struct expr * expr)
+update_ld_motion_stores (struct gcse_expr * expr)
{
struct ls_expr * mem_ptr;
for ( ; list != NULL_RTX; list = XEXP (list, 1))
{
- rtx insn = XEXP (list, 0);
+ rtx_insn *insn = as_a <rtx_insn *> (XEXP (list, 0));
rtx pat = PATTERN (insn);
rtx src = SET_SRC (pat);
rtx reg = expr->reaching_reg;
- rtx copy;
/* If we've already copied it, continue. */
if (expr->reaching_reg == src)
fprintf (dump_file, "\n");
}
- copy = gen_move_insn (reg, copy_rtx (SET_SRC (pat)));
+ rtx_insn *copy = gen_move_insn (reg, copy_rtx (SET_SRC (pat)));
emit_insn_before (copy, insn);
SET_SRC (pat) = reg;
df_insn_rescan (insn);
return new pass_rtl_hoist (ctxt);
}
+/* Reset all state within gcse.c so that we can rerun the compiler
+ within the same process. For use by toplev::finalize. */
+
+void
+gcse_c_finalize (void)
+{
+ test_insn = NULL;
+}
+
#include "gt-gcse.h"