2012-03-27 23:13:14 +00:00
|
|
|
|
/* Post reload partially redundant load elimination
|
2022-10-27 18:55:19 +00:00
|
|
|
|
Copyright (C) 2004-2022 Free Software Foundation, Inc.
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
|
|
|
version.
|
|
|
|
|
|
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
|
for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with GCC; see the file COPYING3. If not see
|
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#include "system.h"
|
|
|
|
|
#include "coretypes.h"
|
2017-04-10 11:32:00 +00:00
|
|
|
|
#include "backend.h"
|
|
|
|
|
#include "target.h"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#include "rtl.h"
|
|
|
|
|
#include "tree.h"
|
2017-04-10 11:32:00 +00:00
|
|
|
|
#include "predict.h"
|
|
|
|
|
#include "df.h"
|
2017-10-07 00:16:47 +00:00
|
|
|
|
#include "memmodel.h"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#include "tm_p.h"
|
|
|
|
|
#include "insn-config.h"
|
2017-04-10 11:32:00 +00:00
|
|
|
|
#include "emit-rtl.h"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#include "recog.h"
|
2017-04-10 11:32:00 +00:00
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
#include "cfgrtl.h"
|
|
|
|
|
#include "profile.h"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
#include "expr.h"
|
|
|
|
|
#include "tree-pass.h"
|
|
|
|
|
#include "dbgcnt.h"
|
2022-10-27 18:55:19 +00:00
|
|
|
|
#include "intl.h"
|
2015-08-28 15:33:40 +00:00
|
|
|
|
#include "gcse-common.h"
|
2022-10-27 18:55:19 +00:00
|
|
|
|
#include "gcse.h"
|
|
|
|
|
#include "regs.h"
|
|
|
|
|
#include "function-abi.h"
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* The following code implements gcse after reload, the purpose of this
|
|
|
|
|
pass is to cleanup redundant loads generated by reload and other
|
|
|
|
|
optimizations that come after gcse. It searches for simple inter-block
|
|
|
|
|
redundancies and tries to eliminate them by adding moves and loads
|
|
|
|
|
in cold places.
|
|
|
|
|
|
|
|
|
|
Perform partially redundant load elimination, try to eliminate redundant
|
|
|
|
|
loads created by the reload pass. We try to look for full or partial
|
|
|
|
|
redundant loads fed by one or more loads/stores in predecessor BBs,
|
|
|
|
|
and try adding loads to make them fully redundant. We also check if
|
|
|
|
|
it's worth adding loads to be able to delete the redundant load.
|
|
|
|
|
|
|
|
|
|
Algorithm:
|
|
|
|
|
1. Build available expressions hash table:
|
|
|
|
|
For each load/store instruction, if the loaded/stored memory didn't
|
|
|
|
|
change until the end of the basic block add this memory expression to
|
|
|
|
|
the hash table.
|
|
|
|
|
2. Perform Redundancy elimination:
|
|
|
|
|
For each load instruction do the following:
|
|
|
|
|
perform partial redundancy elimination, check if it's worth adding
|
|
|
|
|
loads to make the load fully redundant. If so add loads and
|
|
|
|
|
register copies and delete the load.
|
|
|
|
|
3. Delete instructions made redundant in step 2.
|
|
|
|
|
|
|
|
|
|
Future enhancement:
|
|
|
|
|
If the loaded register is used/defined between load and some store,
|
|
|
|
|
look for some other free register between load and all its stores,
|
|
|
|
|
and replace the load with a copy from this register to the loaded
|
|
|
|
|
register.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Keep statistics of this pass. */
|
|
|
|
|
static struct
|
|
|
|
|
{
|
|
|
|
|
int moves_inserted;
|
|
|
|
|
int copies_inserted;
|
|
|
|
|
int insns_deleted;
|
|
|
|
|
} stats;
|
|
|
|
|
|
|
|
|
|
/* We need to keep a hash table of expressions. The table entries are of
|
|
|
|
|
type 'struct expr', and for each expression there is a single linked
|
|
|
|
|
list of occurrences. */
|
|
|
|
|
|
|
|
|
|
/* Expression elements in the hash table. */
|
|
|
|
|
struct expr
|
|
|
|
|
{
|
|
|
|
|
/* The expression (SET_SRC for expressions, PATTERN for assignments). */
|
|
|
|
|
rtx expr;
|
|
|
|
|
|
|
|
|
|
/* The same hash for this entry. */
|
|
|
|
|
hashval_t hash;
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
/* Index in the transparent bitmaps. */
|
|
|
|
|
unsigned int bitmap_index;
|
|
|
|
|
|
2012-03-27 23:13:14 +00:00
|
|
|
|
/* List of available occurrence in basic blocks in the function. */
|
|
|
|
|
struct occr *avail_occr;
|
|
|
|
|
};
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
/* Hashtable helpers. */
|
|
|
|
|
|
2017-04-10 11:32:00 +00:00
|
|
|
|
struct expr_hasher : nofree_ptr_hash <expr>
|
2014-09-21 17:33:12 +00:00
|
|
|
|
{
|
2017-04-10 11:32:00 +00:00
|
|
|
|
static inline hashval_t hash (const expr *);
|
|
|
|
|
static inline bool equal (const expr *, const expr *);
|
2014-09-21 17:33:12 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Hash expression X.
|
|
|
|
|
DO_NOT_RECORD_P is a boolean indicating if a volatile operand is found
|
|
|
|
|
or if the expression contains something we don't want to insert in the
|
|
|
|
|
table. */
|
|
|
|
|
|
|
|
|
|
static hashval_t
|
|
|
|
|
hash_expr (rtx x, int *do_not_record_p)
|
|
|
|
|
{
|
|
|
|
|
*do_not_record_p = 0;
|
|
|
|
|
return hash_rtx (x, GET_MODE (x), do_not_record_p,
|
|
|
|
|
NULL, /*have_reg_qty=*/false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Callback for hashtab.
|
|
|
|
|
Return the hash value for expression EXP. We don't actually hash
|
|
|
|
|
here, we just return the cached hash value. */
|
|
|
|
|
|
|
|
|
|
inline hashval_t
|
2017-04-10 11:32:00 +00:00
|
|
|
|
expr_hasher::hash (const expr *exp)
|
2014-09-21 17:33:12 +00:00
|
|
|
|
{
|
|
|
|
|
return exp->hash;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Callback for hashtab.
|
|
|
|
|
Return nonzero if exp1 is equivalent to exp2. */
|
|
|
|
|
|
|
|
|
|
inline bool
|
2017-04-10 11:32:00 +00:00
|
|
|
|
expr_hasher::equal (const expr *exp1, const expr *exp2)
|
2014-09-21 17:33:12 +00:00
|
|
|
|
{
|
|
|
|
|
int equiv_p = exp_equiv_p (exp1->expr, exp2->expr, 0, true);
|
|
|
|
|
|
|
|
|
|
gcc_assert (!equiv_p || exp1->hash == exp2->hash);
|
|
|
|
|
return equiv_p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The table itself. */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
static hash_table<expr_hasher> *expr_table;
|
2014-09-21 17:33:12 +00:00
|
|
|
|
|
|
|
|
|
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static struct obstack expr_obstack;
|
|
|
|
|
|
|
|
|
|
/* Occurrence of an expression.
|
|
|
|
|
There is at most one occurrence per basic block. If a pattern appears
|
|
|
|
|
more than once, the last appearance is used. */
|
|
|
|
|
|
|
|
|
|
struct occr
|
|
|
|
|
{
|
|
|
|
|
/* Next occurrence of this expression. */
|
|
|
|
|
struct occr *next;
|
|
|
|
|
/* The insn that computes the expression. */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
/* Nonzero if this [anticipatable] occurrence has been deleted. */
|
|
|
|
|
char deleted_p;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct obstack occr_obstack;
|
|
|
|
|
|
|
|
|
|
/* The following structure holds the information about the occurrences of
|
|
|
|
|
the redundant instructions. */
|
|
|
|
|
struct unoccr
|
|
|
|
|
{
|
|
|
|
|
struct unoccr *next;
|
|
|
|
|
edge pred;
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct obstack unoccr_obstack;
|
|
|
|
|
|
|
|
|
|
/* Array where each element is the CUID if the insn that last set the hard
|
|
|
|
|
register with the number of the element, since the start of the current
|
|
|
|
|
basic block.
|
|
|
|
|
|
|
|
|
|
This array is used during the building of the hash table (step 1) to
|
|
|
|
|
determine if a reg is killed before the end of a basic block.
|
|
|
|
|
|
|
|
|
|
It is also used when eliminating partial redundancies (step 2) to see
|
|
|
|
|
if a reg was modified since the start of a basic block. */
|
|
|
|
|
static int *reg_avail_info;
|
|
|
|
|
|
|
|
|
|
/* A list of insns that may modify memory within the current basic block. */
|
|
|
|
|
struct modifies_mem
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
struct modifies_mem *next;
|
|
|
|
|
};
|
|
|
|
|
static struct modifies_mem *modifies_mem_list;
|
|
|
|
|
|
|
|
|
|
/* The modifies_mem structs also go on an obstack, only this obstack is
|
|
|
|
|
freed each time after completing the analysis or transformations on
|
|
|
|
|
a basic block. So we allocate a dummy modifies_mem_obstack_bottom
|
|
|
|
|
object on the obstack to keep track of the bottom of the obstack. */
|
|
|
|
|
static struct obstack modifies_mem_obstack;
|
|
|
|
|
static struct modifies_mem *modifies_mem_obstack_bottom;
|
|
|
|
|
|
|
|
|
|
/* Mapping of insn UIDs to CUIDs.
|
|
|
|
|
CUIDs are like UIDs except they increase monotonically in each basic
|
|
|
|
|
block, have no gaps, and only apply to real insns. */
|
|
|
|
|
static int *uid_cuid;
|
|
|
|
|
#define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
|
2015-08-28 15:33:40 +00:00
|
|
|
|
|
|
|
|
|
/* Bitmap of blocks which have memory stores. */
|
|
|
|
|
static bitmap modify_mem_list_set;
|
|
|
|
|
|
|
|
|
|
/* Bitmap of blocks which have calls. */
|
|
|
|
|
static bitmap blocks_with_calls;
|
|
|
|
|
|
|
|
|
|
/* Vector indexed by block # with a list of all the insns that
|
|
|
|
|
modify memory within the block. */
|
|
|
|
|
static vec<rtx_insn *> *modify_mem_list;
|
|
|
|
|
|
|
|
|
|
/* Vector indexed by block # with a canonicalized list of insns
|
|
|
|
|
that modify memory in the block. */
|
|
|
|
|
static vec<modify_pair> *canon_modify_mem_list;
|
|
|
|
|
|
|
|
|
|
/* Vector of simple bitmaps indexed by block number. Each component sbitmap
|
|
|
|
|
indicates which expressions are transparent through the block. */
|
|
|
|
|
static sbitmap *transp;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Helpers for memory allocation/freeing. */
|
|
|
|
|
static void alloc_mem (void);
|
|
|
|
|
static void free_mem (void);
|
|
|
|
|
|
|
|
|
|
/* Support for hash table construction and transformations. */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
static bool oprs_unchanged_p (rtx, rtx_insn *, bool);
|
|
|
|
|
static void record_last_reg_set_info (rtx_insn *, rtx);
|
|
|
|
|
static void record_last_reg_set_info_regno (rtx_insn *, int);
|
|
|
|
|
static void record_last_mem_set_info (rtx_insn *);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static void record_last_set_info (rtx, const_rtx, void *);
|
2015-08-28 15:33:40 +00:00
|
|
|
|
static void record_opr_changes (rtx_insn *);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
static void find_mem_conflicts (rtx, const_rtx, void *);
|
|
|
|
|
static int load_killed_in_block_p (int, rtx, bool);
|
|
|
|
|
static void reset_opr_set_tables (void);
|
|
|
|
|
|
|
|
|
|
/* Hash table support. */
|
|
|
|
|
static hashval_t hash_expr (rtx, int *);
|
2015-08-28 15:33:40 +00:00
|
|
|
|
static void insert_expr_in_table (rtx, rtx_insn *);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static struct expr *lookup_expr_in_table (rtx);
|
|
|
|
|
static void dump_hash_table (FILE *);
|
|
|
|
|
|
|
|
|
|
/* Helpers for eliminate_partially_redundant_load. */
|
|
|
|
|
static bool reg_killed_on_edge (rtx, edge);
|
|
|
|
|
static bool reg_used_on_edge (rtx, edge);
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
static rtx get_avail_load_store_reg (rtx_insn *);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
static bool bb_has_well_behaved_predecessors (basic_block);
|
2015-08-28 15:33:40 +00:00
|
|
|
|
static struct occr* get_bb_avail_insn (basic_block, struct occr *, int);
|
|
|
|
|
static void hash_scan_set (rtx_insn *);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
static void compute_hash_table (void);
|
|
|
|
|
|
|
|
|
|
/* The work horses of this pass. */
|
|
|
|
|
static void eliminate_partially_redundant_load (basic_block,
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *,
|
2012-03-27 23:13:14 +00:00
|
|
|
|
struct expr *);
|
|
|
|
|
static void eliminate_partially_redundant_loads (void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Allocate memory for the CUID mapping array and register/memory
|
|
|
|
|
tracking tables. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
alloc_mem (void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
basic_block bb;
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* Find the largest UID and create a mapping from UIDs to CUIDs. */
|
|
|
|
|
uid_cuid = XCNEWVEC (int, get_max_uid () + 1);
|
|
|
|
|
i = 1;
|
2014-09-21 17:33:12 +00:00
|
|
|
|
FOR_EACH_BB_FN (bb, cfun)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
FOR_BB_INSNS (bb, insn)
|
|
|
|
|
{
|
|
|
|
|
if (INSN_P (insn))
|
|
|
|
|
uid_cuid[INSN_UID (insn)] = i++;
|
|
|
|
|
else
|
|
|
|
|
uid_cuid[INSN_UID (insn)] = i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Allocate the available expressions hash table. We don't want to
|
|
|
|
|
make the hash table too small, but unnecessarily making it too large
|
2022-10-27 18:55:19 +00:00
|
|
|
|
also doesn't help. The i/4 is a gcse.cc relic, and seems like a
|
2012-03-27 23:13:14 +00:00
|
|
|
|
reasonable choice. */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
expr_table = new hash_table<expr_hasher> (MAX (i / 4, 13));
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* We allocate everything on obstacks because we often can roll back
|
|
|
|
|
the whole obstack to some point. Freeing obstacks is very fast. */
|
|
|
|
|
gcc_obstack_init (&expr_obstack);
|
|
|
|
|
gcc_obstack_init (&occr_obstack);
|
|
|
|
|
gcc_obstack_init (&unoccr_obstack);
|
|
|
|
|
gcc_obstack_init (&modifies_mem_obstack);
|
|
|
|
|
|
|
|
|
|
/* Working array used to track the last set for each register
|
|
|
|
|
in the current block. */
|
|
|
|
|
reg_avail_info = (int *) xmalloc (FIRST_PSEUDO_REGISTER * sizeof (int));
|
|
|
|
|
|
|
|
|
|
/* Put a dummy modifies_mem object on the modifies_mem_obstack, so we
|
|
|
|
|
can roll it back in reset_opr_set_tables. */
|
|
|
|
|
modifies_mem_obstack_bottom =
|
|
|
|
|
(struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
|
|
|
|
|
sizeof (struct modifies_mem));
|
2015-08-28 15:33:40 +00:00
|
|
|
|
|
|
|
|
|
blocks_with_calls = BITMAP_ALLOC (NULL);
|
|
|
|
|
modify_mem_list_set = BITMAP_ALLOC (NULL);
|
|
|
|
|
|
|
|
|
|
modify_mem_list = (vec_rtx_heap *) xcalloc (last_basic_block_for_fn (cfun),
|
|
|
|
|
sizeof (vec_rtx_heap));
|
|
|
|
|
canon_modify_mem_list
|
|
|
|
|
= (vec_modify_pair_heap *) xcalloc (last_basic_block_for_fn (cfun),
|
|
|
|
|
sizeof (vec_modify_pair_heap));
|
2012-03-27 23:13:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Free memory allocated by alloc_mem. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
free_mem (void)
|
|
|
|
|
{
|
|
|
|
|
free (uid_cuid);
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
delete expr_table;
|
|
|
|
|
expr_table = NULL;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
obstack_free (&expr_obstack, NULL);
|
|
|
|
|
obstack_free (&occr_obstack, NULL);
|
|
|
|
|
obstack_free (&unoccr_obstack, NULL);
|
|
|
|
|
obstack_free (&modifies_mem_obstack, NULL);
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
unsigned i;
|
|
|
|
|
bitmap_iterator bi;
|
|
|
|
|
EXECUTE_IF_SET_IN_BITMAP (modify_mem_list_set, 0, i, bi)
|
|
|
|
|
{
|
|
|
|
|
modify_mem_list[i].release ();
|
|
|
|
|
canon_modify_mem_list[i].release ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BITMAP_FREE (blocks_with_calls);
|
|
|
|
|
BITMAP_FREE (modify_mem_list_set);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
free (reg_avail_info);
|
2017-04-10 11:32:00 +00:00
|
|
|
|
free (modify_mem_list);
|
|
|
|
|
free (canon_modify_mem_list);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Insert expression X in INSN in the hash TABLE.
|
|
|
|
|
If it is already present, record it as the last occurrence in INSN's
|
|
|
|
|
basic block. */
|
|
|
|
|
|
|
|
|
|
static void
|
2015-08-28 15:33:40 +00:00
|
|
|
|
insert_expr_in_table (rtx x, rtx_insn *insn)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
int do_not_record_p;
|
|
|
|
|
hashval_t hash;
|
|
|
|
|
struct expr *cur_expr, **slot;
|
2022-10-27 18:55:19 +00:00
|
|
|
|
struct occr *avail_occr;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
hash = hash_expr (x, &do_not_record_p);
|
|
|
|
|
|
|
|
|
|
/* Do not insert expression in the table if it contains volatile operands,
|
|
|
|
|
or if hash_expr determines the expression is something we don't want
|
|
|
|
|
to or can't handle. */
|
|
|
|
|
if (do_not_record_p)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* We anticipate that redundant expressions are rare, so for convenience
|
|
|
|
|
allocate a new hash table element here already and set its fields.
|
|
|
|
|
If we don't do this, we need a hack with a static struct expr. Anyway,
|
|
|
|
|
obstack_free is really fast and one more obstack_alloc doesn't hurt if
|
|
|
|
|
we're going to see more expressions later on. */
|
|
|
|
|
cur_expr = (struct expr *) obstack_alloc (&expr_obstack,
|
|
|
|
|
sizeof (struct expr));
|
|
|
|
|
cur_expr->expr = x;
|
|
|
|
|
cur_expr->hash = hash;
|
|
|
|
|
cur_expr->avail_occr = NULL;
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
slot = expr_table->find_slot_with_hash (cur_expr, hash, INSERT);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
if (! (*slot))
|
2015-08-28 15:33:40 +00:00
|
|
|
|
{
|
|
|
|
|
/* The expression isn't found, so insert it. */
|
|
|
|
|
*slot = cur_expr;
|
|
|
|
|
|
|
|
|
|
/* Anytime we add an entry to the table, record the index
|
|
|
|
|
of the new entry. The bitmap index starts counting
|
|
|
|
|
at zero. */
|
|
|
|
|
cur_expr->bitmap_index = expr_table->elements () - 1;
|
|
|
|
|
}
|
2012-03-27 23:13:14 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* The expression is already in the table, so roll back the
|
|
|
|
|
obstack and use the existing table entry. */
|
|
|
|
|
obstack_free (&expr_obstack, cur_expr);
|
|
|
|
|
cur_expr = *slot;
|
|
|
|
|
}
|
|
|
|
|
|
2022-10-27 18:55:19 +00:00
|
|
|
|
/* Search for another occurrence in the same basic block. We insert
|
|
|
|
|
insns blockwise from start to end, so keep appending to the
|
|
|
|
|
start of the list so we have to check only a single element. */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
avail_occr = cur_expr->avail_occr;
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (avail_occr
|
|
|
|
|
&& BLOCK_FOR_INSN (avail_occr->insn) == BLOCK_FOR_INSN (insn))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
avail_occr->insn = insn;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* First occurrence of this expression in this basic block. */
|
|
|
|
|
avail_occr = (struct occr *) obstack_alloc (&occr_obstack,
|
|
|
|
|
sizeof (struct occr));
|
|
|
|
|
avail_occr->insn = insn;
|
2022-10-27 18:55:19 +00:00
|
|
|
|
avail_occr->next = cur_expr->avail_occr;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
avail_occr->deleted_p = 0;
|
2022-10-27 18:55:19 +00:00
|
|
|
|
cur_expr->avail_occr = avail_occr;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Lookup pattern PAT in the expression hash table.
|
|
|
|
|
The result is a pointer to the table entry, or NULL if not found. */
|
|
|
|
|
|
|
|
|
|
static struct expr *
|
|
|
|
|
lookup_expr_in_table (rtx pat)
|
|
|
|
|
{
|
|
|
|
|
int do_not_record_p;
|
|
|
|
|
struct expr **slot, *tmp_expr;
|
|
|
|
|
hashval_t hash = hash_expr (pat, &do_not_record_p);
|
|
|
|
|
|
|
|
|
|
if (do_not_record_p)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
tmp_expr = (struct expr *) obstack_alloc (&expr_obstack,
|
|
|
|
|
sizeof (struct expr));
|
|
|
|
|
tmp_expr->expr = pat;
|
|
|
|
|
tmp_expr->hash = hash;
|
|
|
|
|
tmp_expr->avail_occr = NULL;
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
slot = expr_table->find_slot_with_hash (tmp_expr, hash, INSERT);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
obstack_free (&expr_obstack, tmp_expr);
|
|
|
|
|
|
|
|
|
|
if (!slot)
|
|
|
|
|
return NULL;
|
|
|
|
|
else
|
|
|
|
|
return (*slot);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Dump all expressions and occurrences that are currently in the
|
|
|
|
|
expression hash table to FILE. */
|
|
|
|
|
|
|
|
|
|
/* This helper is called via htab_traverse. */
|
2014-09-21 17:33:12 +00:00
|
|
|
|
int
|
|
|
|
|
dump_expr_hash_table_entry (expr **slot, FILE *file)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
2014-09-21 17:33:12 +00:00
|
|
|
|
struct expr *exprs = *slot;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
struct occr *occr;
|
|
|
|
|
|
|
|
|
|
fprintf (file, "expr: ");
|
2014-09-21 17:33:12 +00:00
|
|
|
|
print_rtl (file, exprs->expr);
|
|
|
|
|
fprintf (file,"\nhashcode: %u\n", exprs->hash);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
fprintf (file,"list of occurrences:\n");
|
2014-09-21 17:33:12 +00:00
|
|
|
|
occr = exprs->avail_occr;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
while (occr)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn = occr->insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
print_rtl_single (file, insn);
|
|
|
|
|
fprintf (file, "\n");
|
|
|
|
|
occr = occr->next;
|
|
|
|
|
}
|
|
|
|
|
fprintf (file, "\n");
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_hash_table (FILE *file)
|
|
|
|
|
{
|
|
|
|
|
fprintf (file, "\n\nexpression hash table\n");
|
|
|
|
|
fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n",
|
2015-08-28 15:33:40 +00:00
|
|
|
|
(long) expr_table->size (),
|
|
|
|
|
(long) expr_table->elements (),
|
|
|
|
|
expr_table->collisions ());
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (!expr_table->is_empty ())
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
fprintf (file, "\n\ntable entries:\n");
|
2015-08-28 15:33:40 +00:00
|
|
|
|
expr_table->traverse <FILE *, dump_expr_hash_table_entry> (file);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
}
|
|
|
|
|
fprintf (file, "\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return true if register X is recorded as being set by an instruction
|
|
|
|
|
whose CUID is greater than the one given. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
reg_changed_after_insn_p (rtx x, int cuid)
|
|
|
|
|
{
|
|
|
|
|
unsigned int regno, end_regno;
|
|
|
|
|
|
|
|
|
|
regno = REGNO (x);
|
2017-04-10 11:32:00 +00:00
|
|
|
|
end_regno = END_REGNO (x);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
do
|
|
|
|
|
if (reg_avail_info[regno] > cuid)
|
|
|
|
|
return true;
|
|
|
|
|
while (++regno < end_regno);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return nonzero if the operands of expression X are unchanged
|
|
|
|
|
1) from the start of INSN's basic block up to but not including INSN
|
|
|
|
|
if AFTER_INSN is false, or
|
|
|
|
|
2) from INSN to the end of INSN's basic block if AFTER_INSN is true. */
|
|
|
|
|
|
|
|
|
|
static bool
|
2015-08-28 15:33:40 +00:00
|
|
|
|
oprs_unchanged_p (rtx x, rtx_insn *insn, bool after_insn)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
int i, j;
|
|
|
|
|
enum rtx_code code;
|
|
|
|
|
const char *fmt;
|
|
|
|
|
|
|
|
|
|
if (x == 0)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
code = GET_CODE (x);
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case REG:
|
|
|
|
|
/* We are called after register allocation. */
|
|
|
|
|
gcc_assert (REGNO (x) < FIRST_PSEUDO_REGISTER);
|
|
|
|
|
if (after_insn)
|
|
|
|
|
return !reg_changed_after_insn_p (x, INSN_CUID (insn) - 1);
|
|
|
|
|
else
|
|
|
|
|
return !reg_changed_after_insn_p (x, 0);
|
|
|
|
|
|
|
|
|
|
case MEM:
|
|
|
|
|
if (load_killed_in_block_p (INSN_CUID (insn), x, after_insn))
|
|
|
|
|
return 0;
|
|
|
|
|
else
|
|
|
|
|
return oprs_unchanged_p (XEXP (x, 0), insn, after_insn);
|
|
|
|
|
|
|
|
|
|
case PC:
|
|
|
|
|
case CONST:
|
2014-09-21 17:33:12 +00:00
|
|
|
|
CASE_CONST_ANY:
|
2012-03-27 23:13:14 +00:00
|
|
|
|
case SYMBOL_REF:
|
|
|
|
|
case LABEL_REF:
|
|
|
|
|
case ADDR_VEC:
|
|
|
|
|
case ADDR_DIFF_VEC:
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
case PRE_DEC:
|
|
|
|
|
case PRE_INC:
|
|
|
|
|
case POST_DEC:
|
|
|
|
|
case POST_INC:
|
|
|
|
|
case PRE_MODIFY:
|
|
|
|
|
case POST_MODIFY:
|
|
|
|
|
if (after_insn)
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
|
|
|
|
|
{
|
|
|
|
|
if (fmt[i] == 'e')
|
|
|
|
|
{
|
|
|
|
|
if (! oprs_unchanged_p (XEXP (x, i), insn, after_insn))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
else if (fmt[i] == 'E')
|
|
|
|
|
for (j = 0; j < XVECLEN (x, i); j++)
|
|
|
|
|
if (! oprs_unchanged_p (XVECEXP (x, i, j), insn, after_insn))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Used for communication between find_mem_conflicts and
|
|
|
|
|
load_killed_in_block_p. Nonzero if find_mem_conflicts finds a
|
|
|
|
|
conflict between two memory references.
|
|
|
|
|
This is a bit of a hack to work around the limitations of note_stores. */
|
|
|
|
|
static int mems_conflict_p;
|
|
|
|
|
|
|
|
|
|
/* DEST is the output of an instruction. If it is a memory reference, and
|
|
|
|
|
possibly conflicts with the load found in DATA, then set mems_conflict_p
|
|
|
|
|
to a nonzero value. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
find_mem_conflicts (rtx dest, const_rtx setter ATTRIBUTE_UNUSED,
|
|
|
|
|
void *data)
|
|
|
|
|
{
|
|
|
|
|
rtx mem_op = (rtx) data;
|
|
|
|
|
|
|
|
|
|
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 the load. Note
|
|
|
|
|
that function calls are assumed to clobber memory, but are handled
|
|
|
|
|
elsewhere. */
|
|
|
|
|
if (! MEM_P (dest))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (true_dependence (dest, GET_MODE (dest), mem_op))
|
|
|
|
|
mems_conflict_p = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return nonzero if the expression in X (a memory reference) is killed
|
|
|
|
|
in the current basic block before (if AFTER_INSN is false) or after
|
|
|
|
|
(if AFTER_INSN is true) the insn with the CUID in UID_LIMIT.
|
|
|
|
|
|
|
|
|
|
This function assumes that the modifies_mem table is flushed when
|
|
|
|
|
the hash table construction or redundancy elimination phases start
|
|
|
|
|
processing a new basic block. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
load_killed_in_block_p (int uid_limit, rtx x, bool after_insn)
|
|
|
|
|
{
|
|
|
|
|
struct modifies_mem *list_entry = modifies_mem_list;
|
|
|
|
|
|
|
|
|
|
while (list_entry)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *setter = list_entry->insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* Ignore entries in the list that do not apply. */
|
|
|
|
|
if ((after_insn
|
|
|
|
|
&& INSN_CUID (setter) < uid_limit)
|
|
|
|
|
|| (! after_insn
|
|
|
|
|
&& INSN_CUID (setter) > uid_limit))
|
|
|
|
|
{
|
|
|
|
|
list_entry = list_entry->next;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If SETTER is a call everything is clobbered. Note that calls
|
|
|
|
|
to pure functions are never put on the list, so we need not
|
|
|
|
|
worry about them. */
|
|
|
|
|
if (CALL_P (setter))
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
/* SETTER must be an insn of some kind that sets memory. Call
|
|
|
|
|
note_stores to examine each hunk of memory that is modified.
|
|
|
|
|
It will set mems_conflict_p to nonzero if there may be a
|
|
|
|
|
conflict between X and SETTER. */
|
|
|
|
|
mems_conflict_p = 0;
|
2022-10-27 18:55:19 +00:00
|
|
|
|
note_stores (setter, find_mem_conflicts, x);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
if (mems_conflict_p)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
list_entry = list_entry->next;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Record register first/last/block set information for REGNO in INSN. */
|
|
|
|
|
|
|
|
|
|
static inline void
|
2015-08-28 15:33:40 +00:00
|
|
|
|
record_last_reg_set_info (rtx_insn *insn, rtx reg)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
unsigned int regno, end_regno;
|
|
|
|
|
|
|
|
|
|
regno = REGNO (reg);
|
2017-04-10 11:32:00 +00:00
|
|
|
|
end_regno = END_REGNO (reg);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
do
|
|
|
|
|
reg_avail_info[regno] = INSN_CUID (insn);
|
|
|
|
|
while (++regno < end_regno);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
2015-08-28 15:33:40 +00:00
|
|
|
|
record_last_reg_set_info_regno (rtx_insn *insn, int regno)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
reg_avail_info[regno] = INSN_CUID (insn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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
|
2015-08-28 15:33:40 +00:00
|
|
|
|
record_last_mem_set_info (rtx_insn *insn)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
struct modifies_mem *list_entry;
|
|
|
|
|
|
|
|
|
|
list_entry = (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
|
|
|
|
|
sizeof (struct modifies_mem));
|
|
|
|
|
list_entry->insn = insn;
|
|
|
|
|
list_entry->next = modifies_mem_list;
|
|
|
|
|
modifies_mem_list = list_entry;
|
2015-08-28 15:33:40 +00:00
|
|
|
|
|
|
|
|
|
record_last_mem_set_info_common (insn, modify_mem_list,
|
|
|
|
|
canon_modify_mem_list,
|
|
|
|
|
modify_mem_list_set,
|
|
|
|
|
blocks_with_calls);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Called from compute_hash_table via note_stores to handle one
|
|
|
|
|
SET or CLOBBER in an insn. DATA is really the instruction in which
|
|
|
|
|
the SET is taking place. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
record_last_set_info (rtx dest, const_rtx setter ATTRIBUTE_UNUSED, void *data)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *last_set_insn = (rtx_insn *) data;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
if (GET_CODE (dest) == SUBREG)
|
|
|
|
|
dest = SUBREG_REG (dest);
|
|
|
|
|
|
|
|
|
|
if (REG_P (dest))
|
|
|
|
|
record_last_reg_set_info (last_set_insn, dest);
|
|
|
|
|
else if (MEM_P (dest))
|
|
|
|
|
{
|
|
|
|
|
/* Ignore pushes, they don't clobber memory. They may still
|
|
|
|
|
clobber the stack pointer though. Some targets do argument
|
|
|
|
|
pushes without adding REG_INC notes. See e.g. PR25196,
|
|
|
|
|
where a pushsi2 on i386 doesn't have REG_INC notes. Note
|
|
|
|
|
such changes here too. */
|
|
|
|
|
if (! push_operand (dest, GET_MODE (dest)))
|
|
|
|
|
record_last_mem_set_info (last_set_insn);
|
|
|
|
|
else
|
|
|
|
|
record_last_reg_set_info_regno (last_set_insn, STACK_POINTER_REGNUM);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Reset tables used to keep track of what's still available since the
|
|
|
|
|
start of the block. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
reset_opr_set_tables (void)
|
|
|
|
|
{
|
|
|
|
|
memset (reg_avail_info, 0, FIRST_PSEUDO_REGISTER * sizeof (int));
|
|
|
|
|
obstack_free (&modifies_mem_obstack, modifies_mem_obstack_bottom);
|
|
|
|
|
modifies_mem_list = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Record things set by INSN.
|
|
|
|
|
This data is used by oprs_unchanged_p. */
|
|
|
|
|
|
|
|
|
|
static void
|
2015-08-28 15:33:40 +00:00
|
|
|
|
record_opr_changes (rtx_insn *insn)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
rtx note;
|
|
|
|
|
|
|
|
|
|
/* Find all stores and record them. */
|
2022-10-27 18:55:19 +00:00
|
|
|
|
note_stores (insn, record_last_set_info, insn);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* Also record autoincremented REGs for this insn as changed. */
|
|
|
|
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
|
|
|
|
if (REG_NOTE_KIND (note) == REG_INC)
|
|
|
|
|
record_last_reg_set_info (insn, XEXP (note, 0));
|
|
|
|
|
|
|
|
|
|
/* Finally, if this is a call, record all call clobbers. */
|
|
|
|
|
if (CALL_P (insn))
|
|
|
|
|
{
|
|
|
|
|
unsigned int regno;
|
2014-09-21 17:33:12 +00:00
|
|
|
|
hard_reg_set_iterator hrsi;
|
2022-10-27 18:55:19 +00:00
|
|
|
|
/* We don't track modes of hard registers, so we need to be
|
|
|
|
|
conservative and assume that partial kills are full kills. */
|
|
|
|
|
HARD_REG_SET callee_clobbers
|
|
|
|
|
= insn_callee_abi (insn).full_and_partial_reg_clobbers ();
|
|
|
|
|
EXECUTE_IF_SET_IN_HARD_REG_SET (callee_clobbers, 0, regno, hrsi)
|
2014-09-21 17:33:12 +00:00
|
|
|
|
record_last_reg_set_info_regno (insn, regno);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (! RTL_CONST_OR_PURE_CALL_P (insn)
|
|
|
|
|
|| RTL_LOOPING_CONST_OR_PURE_CALL_P (insn)
|
|
|
|
|
|| can_throw_external (insn))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
record_last_mem_set_info (insn);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Scan the pattern of INSN and add an entry to the hash TABLE.
|
|
|
|
|
After reload we are interested in loads/stores only. */
|
|
|
|
|
|
|
|
|
|
static void
|
2015-08-28 15:33:40 +00:00
|
|
|
|
hash_scan_set (rtx_insn *insn)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
rtx pat = PATTERN (insn);
|
|
|
|
|
rtx src = SET_SRC (pat);
|
|
|
|
|
rtx dest = SET_DEST (pat);
|
|
|
|
|
|
|
|
|
|
/* We are only interested in loads and stores. */
|
|
|
|
|
if (! MEM_P (src) && ! MEM_P (dest))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Don't mess with jumps and nops. */
|
|
|
|
|
if (JUMP_P (insn) || set_noop_p (pat))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (REG_P (dest))
|
|
|
|
|
{
|
|
|
|
|
if (/* Don't CSE something if we can't do a reg/reg copy. */
|
|
|
|
|
can_copy_p (GET_MODE (dest))
|
|
|
|
|
/* Is SET_SRC something we want to gcse? */
|
|
|
|
|
&& general_operand (src, GET_MODE (src))
|
|
|
|
|
#ifdef STACK_REGS
|
|
|
|
|
/* Never consider insns touching the register stack. It may
|
|
|
|
|
create situations that reg-stack cannot handle (e.g. a stack
|
|
|
|
|
register live across an abnormal edge). */
|
|
|
|
|
&& (REGNO (dest) < FIRST_STACK_REG || REGNO (dest) > LAST_STACK_REG)
|
|
|
|
|
#endif
|
|
|
|
|
/* An expression is not available if its operands are
|
|
|
|
|
subsequently modified, including this insn. */
|
|
|
|
|
&& oprs_unchanged_p (src, insn, true))
|
|
|
|
|
{
|
|
|
|
|
insert_expr_in_table (src, insn);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (REG_P (src))
|
|
|
|
|
{
|
|
|
|
|
/* Only record sets of pseudo-regs in the hash table. */
|
|
|
|
|
if (/* Don't CSE something if we can't do a reg/reg copy. */
|
|
|
|
|
can_copy_p (GET_MODE (src))
|
|
|
|
|
/* Is SET_DEST something we want to gcse? */
|
|
|
|
|
&& general_operand (dest, GET_MODE (dest))
|
|
|
|
|
#ifdef STACK_REGS
|
|
|
|
|
/* As above for STACK_REGS. */
|
|
|
|
|
&& (REGNO (src) < FIRST_STACK_REG || REGNO (src) > LAST_STACK_REG)
|
|
|
|
|
#endif
|
|
|
|
|
&& ! (flag_float_store && FLOAT_MODE_P (GET_MODE (dest)))
|
|
|
|
|
/* Check if the memory expression is killed after insn. */
|
|
|
|
|
&& ! load_killed_in_block_p (INSN_CUID (insn) + 1, dest, true)
|
|
|
|
|
&& oprs_unchanged_p (XEXP (dest, 0), insn, true))
|
|
|
|
|
{
|
|
|
|
|
insert_expr_in_table (dest, insn);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Create hash table of memory expressions available at end of basic
|
|
|
|
|
blocks. Basically you should think of this hash table as the
|
|
|
|
|
representation of AVAIL_OUT. This is the set of expressions that
|
|
|
|
|
is generated in a basic block and not killed before the end of the
|
|
|
|
|
same basic block. Notice that this is really a local computation. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
compute_hash_table (void)
|
|
|
|
|
{
|
|
|
|
|
basic_block bb;
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
FOR_EACH_BB_FN (bb, cfun)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
/* First pass over the instructions records information used to
|
|
|
|
|
determine when registers and memory are last set.
|
|
|
|
|
Since we compute a "local" AVAIL_OUT, reset the tables that
|
|
|
|
|
help us keep track of what has been modified since the start
|
|
|
|
|
of the block. */
|
|
|
|
|
reset_opr_set_tables ();
|
|
|
|
|
FOR_BB_INSNS (bb, insn)
|
|
|
|
|
{
|
|
|
|
|
if (INSN_P (insn))
|
|
|
|
|
record_opr_changes (insn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The next pass actually builds the hash table. */
|
|
|
|
|
FOR_BB_INSNS (bb, insn)
|
|
|
|
|
if (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET)
|
|
|
|
|
hash_scan_set (insn);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Check if register REG is killed in any insn waiting to be inserted on
|
|
|
|
|
edge E. This function is required to check that our data flow analysis
|
|
|
|
|
is still valid prior to commit_edge_insertions. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
reg_killed_on_edge (rtx reg, edge e)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
|
|
|
|
|
if (INSN_P (insn) && reg_set_p (reg, insn))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Similar to above - check if register REG is used in any insn waiting
|
|
|
|
|
to be inserted on edge E.
|
|
|
|
|
Assumes no such insn can be a CALL_INSN; if so call reg_used_between_p
|
|
|
|
|
with PREV(insn),NEXT(insn) instead of calling reg_overlap_mentioned_p. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
reg_used_on_edge (rtx reg, edge e)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
|
|
|
|
|
if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the loaded/stored register of a load/store instruction. */
|
|
|
|
|
|
|
|
|
|
static rtx
|
2015-08-28 15:33:40 +00:00
|
|
|
|
get_avail_load_store_reg (rtx_insn *insn)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
if (REG_P (SET_DEST (PATTERN (insn))))
|
|
|
|
|
/* A load. */
|
2014-09-21 17:33:12 +00:00
|
|
|
|
return SET_DEST (PATTERN (insn));
|
2012-03-27 23:13:14 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* A store. */
|
|
|
|
|
gcc_assert (REG_P (SET_SRC (PATTERN (insn))));
|
|
|
|
|
return SET_SRC (PATTERN (insn));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return nonzero if the predecessors of BB are "well behaved". */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
bb_has_well_behaved_predecessors (basic_block bb)
|
|
|
|
|
{
|
|
|
|
|
edge pred;
|
|
|
|
|
edge_iterator ei;
|
|
|
|
|
|
|
|
|
|
if (EDGE_COUNT (bb->preds) == 0)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
FOR_EACH_EDGE (pred, ei, bb->preds)
|
|
|
|
|
{
|
2017-10-07 00:16:47 +00:00
|
|
|
|
/* commit_one_edge_insertion refuses to insert on abnormal edges even if
|
|
|
|
|
the source has only one successor so EDGE_CRITICAL_P is too weak. */
|
|
|
|
|
if ((pred->flags & EDGE_ABNORMAL) && !single_pred_p (pred->dest))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if ((pred->flags & EDGE_ABNORMAL_CALL) && cfun->has_nonlocal_label)
|
|
|
|
|
return false;
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
if (tablejump_p (BB_END (pred->src), NULL, NULL))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Search for the occurrences of expression in BB. */
|
|
|
|
|
|
|
|
|
|
static struct occr*
|
2015-08-28 15:33:40 +00:00
|
|
|
|
get_bb_avail_insn (basic_block bb, struct occr *orig_occr, int bitmap_index)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
struct occr *occr = orig_occr;
|
|
|
|
|
|
2012-03-27 23:13:14 +00:00
|
|
|
|
for (; occr != NULL; occr = occr->next)
|
|
|
|
|
if (BLOCK_FOR_INSN (occr->insn) == bb)
|
|
|
|
|
return occr;
|
2015-08-28 15:33:40 +00:00
|
|
|
|
|
|
|
|
|
/* If we could not find an occurrence in BB, see if BB
|
|
|
|
|
has a single predecessor with an occurrence that is
|
|
|
|
|
transparent through BB. */
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (transp
|
|
|
|
|
&& single_pred_p (bb)
|
2015-08-28 15:33:40 +00:00
|
|
|
|
&& bitmap_bit_p (transp[bb->index], bitmap_index)
|
|
|
|
|
&& (occr = get_bb_avail_insn (single_pred (bb), orig_occr, bitmap_index)))
|
|
|
|
|
{
|
|
|
|
|
rtx avail_reg = get_avail_load_store_reg (occr->insn);
|
|
|
|
|
if (!reg_set_between_p (avail_reg,
|
|
|
|
|
PREV_INSN (BB_HEAD (bb)),
|
|
|
|
|
NEXT_INSN (BB_END (bb)))
|
|
|
|
|
&& !reg_killed_on_edge (avail_reg, single_pred_edge (bb)))
|
|
|
|
|
return occr;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-27 23:13:14 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
/* This helper is called via htab_traverse. */
|
|
|
|
|
int
|
|
|
|
|
compute_expr_transp (expr **slot, FILE *dump_file ATTRIBUTE_UNUSED)
|
|
|
|
|
{
|
|
|
|
|
struct expr *expr = *slot;
|
|
|
|
|
|
|
|
|
|
compute_transp (expr->expr, expr->bitmap_index, transp,
|
|
|
|
|
blocks_with_calls, modify_mem_list_set,
|
|
|
|
|
canon_modify_mem_list);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-27 23:13:14 +00:00
|
|
|
|
/* This handles the case where several stores feed a partially redundant
|
|
|
|
|
load. It checks if the redundancy elimination is possible and if it's
|
|
|
|
|
worth it.
|
|
|
|
|
|
|
|
|
|
Redundancy elimination is possible if,
|
|
|
|
|
1) None of the operands of an insn have been modified since the start
|
|
|
|
|
of the current basic block.
|
|
|
|
|
2) In any predecessor of the current basic block, the same expression
|
|
|
|
|
is generated.
|
|
|
|
|
|
|
|
|
|
See the function body for the heuristics that determine if eliminating
|
|
|
|
|
a redundancy is also worth doing, assuming it is possible. */
|
|
|
|
|
|
|
|
|
|
static void
|
2015-08-28 15:33:40 +00:00
|
|
|
|
eliminate_partially_redundant_load (basic_block bb, rtx_insn *insn,
|
2012-03-27 23:13:14 +00:00
|
|
|
|
struct expr *expr)
|
|
|
|
|
{
|
|
|
|
|
edge pred;
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *avail_insn = NULL;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
rtx avail_reg;
|
|
|
|
|
rtx dest, pat;
|
|
|
|
|
struct occr *a_occr;
|
|
|
|
|
struct unoccr *occr, *avail_occrs = NULL;
|
|
|
|
|
struct unoccr *unoccr, *unavail_occrs = NULL, *rollback_unoccr = NULL;
|
|
|
|
|
int npred_ok = 0;
|
2018-12-28 15:30:48 +00:00
|
|
|
|
profile_count ok_count = profile_count::zero ();
|
|
|
|
|
/* Redundant load execution count. */
|
|
|
|
|
profile_count critical_count = profile_count::zero ();
|
|
|
|
|
/* Execution count of critical edges. */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
edge_iterator ei;
|
|
|
|
|
bool critical_edge_split = false;
|
|
|
|
|
|
|
|
|
|
/* The execution count of the loads to be added to make the
|
|
|
|
|
load fully redundant. */
|
2018-12-28 15:30:48 +00:00
|
|
|
|
profile_count not_ok_count = profile_count::zero ();
|
2012-03-27 23:13:14 +00:00
|
|
|
|
basic_block pred_bb;
|
|
|
|
|
|
|
|
|
|
pat = PATTERN (insn);
|
|
|
|
|
dest = SET_DEST (pat);
|
|
|
|
|
|
|
|
|
|
/* Check that the loaded register is not used, set, or killed from the
|
|
|
|
|
beginning of the block. */
|
|
|
|
|
if (reg_changed_after_insn_p (dest, 0)
|
|
|
|
|
|| reg_used_between_p (dest, PREV_INSN (BB_HEAD (bb)), insn))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Check potential for replacing load with copy for predecessors. */
|
|
|
|
|
FOR_EACH_EDGE (pred, ei, bb->preds)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *next_pred_bb_end;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
2015-08-28 15:33:40 +00:00
|
|
|
|
avail_insn = NULL;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
avail_reg = NULL_RTX;
|
|
|
|
|
pred_bb = pred->src;
|
2015-08-28 15:33:40 +00:00
|
|
|
|
for (a_occr = get_bb_avail_insn (pred_bb,
|
|
|
|
|
expr->avail_occr,
|
|
|
|
|
expr->bitmap_index);
|
|
|
|
|
a_occr;
|
|
|
|
|
a_occr = get_bb_avail_insn (pred_bb,
|
|
|
|
|
a_occr->next,
|
|
|
|
|
expr->bitmap_index))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
/* Check if the loaded register is not used. */
|
|
|
|
|
avail_insn = a_occr->insn;
|
|
|
|
|
avail_reg = get_avail_load_store_reg (avail_insn);
|
|
|
|
|
gcc_assert (avail_reg);
|
|
|
|
|
|
|
|
|
|
/* Make sure we can generate a move from register avail_reg to
|
|
|
|
|
dest. */
|
2017-04-10 11:32:00 +00:00
|
|
|
|
rtx_insn *move = gen_move_insn (copy_rtx (dest),
|
|
|
|
|
copy_rtx (avail_reg));
|
2015-08-28 15:33:40 +00:00
|
|
|
|
extract_insn (move);
|
|
|
|
|
if (! constrain_operands (1, get_preferred_alternatives (insn,
|
|
|
|
|
pred_bb))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|| reg_killed_on_edge (avail_reg, pred)
|
|
|
|
|
|| reg_used_on_edge (dest, pred))
|
|
|
|
|
{
|
|
|
|
|
avail_insn = NULL;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2015-08-28 15:33:40 +00:00
|
|
|
|
next_pred_bb_end = NEXT_INSN (BB_END (BLOCK_FOR_INSN (avail_insn)));
|
2012-03-27 23:13:14 +00:00
|
|
|
|
if (!reg_set_between_p (avail_reg, avail_insn, next_pred_bb_end))
|
|
|
|
|
/* AVAIL_INSN remains non-null. */
|
|
|
|
|
break;
|
|
|
|
|
else
|
|
|
|
|
avail_insn = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-28 15:30:48 +00:00
|
|
|
|
if (EDGE_CRITICAL_P (pred) && pred->count ().initialized_p ())
|
|
|
|
|
critical_count += pred->count ();
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
if (avail_insn != NULL_RTX)
|
|
|
|
|
{
|
|
|
|
|
npred_ok++;
|
2018-12-28 15:30:48 +00:00
|
|
|
|
if (pred->count ().initialized_p ())
|
|
|
|
|
ok_count = ok_count + pred->count ();
|
2012-03-27 23:13:14 +00:00
|
|
|
|
if (! set_noop_p (PATTERN (gen_move_insn (copy_rtx (dest),
|
|
|
|
|
copy_rtx (avail_reg)))))
|
|
|
|
|
{
|
|
|
|
|
/* Check if there is going to be a split. */
|
|
|
|
|
if (EDGE_CRITICAL_P (pred))
|
|
|
|
|
critical_edge_split = true;
|
|
|
|
|
}
|
|
|
|
|
else /* Its a dead move no need to generate. */
|
|
|
|
|
continue;
|
|
|
|
|
occr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
|
|
|
|
|
sizeof (struct unoccr));
|
|
|
|
|
occr->insn = avail_insn;
|
|
|
|
|
occr->pred = pred;
|
|
|
|
|
occr->next = avail_occrs;
|
|
|
|
|
avail_occrs = occr;
|
|
|
|
|
if (! rollback_unoccr)
|
|
|
|
|
rollback_unoccr = occr;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Adding a load on a critical edge will cause a split. */
|
|
|
|
|
if (EDGE_CRITICAL_P (pred))
|
|
|
|
|
critical_edge_split = true;
|
2018-12-28 15:30:48 +00:00
|
|
|
|
if (pred->count ().initialized_p ())
|
|
|
|
|
not_ok_count = not_ok_count + pred->count ();
|
2012-03-27 23:13:14 +00:00
|
|
|
|
unoccr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
|
|
|
|
|
sizeof (struct unoccr));
|
2015-08-28 15:33:40 +00:00
|
|
|
|
unoccr->insn = NULL;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
unoccr->pred = pred;
|
|
|
|
|
unoccr->next = unavail_occrs;
|
|
|
|
|
unavail_occrs = unoccr;
|
|
|
|
|
if (! rollback_unoccr)
|
|
|
|
|
rollback_unoccr = unoccr;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (/* No load can be replaced by copy. */
|
|
|
|
|
npred_ok == 0
|
|
|
|
|
/* Prevent exploding the code. */
|
|
|
|
|
|| (optimize_bb_for_size_p (bb) && npred_ok > 1)
|
|
|
|
|
/* If we don't have profile information we cannot tell if splitting
|
|
|
|
|
a critical edge is profitable or not so don't do it. */
|
2019-06-02 15:48:37 +00:00
|
|
|
|
|| ((!profile_info || profile_status_for_fn (cfun) != PROFILE_READ
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|| targetm.cannot_modify_jumps_p ())
|
|
|
|
|
&& critical_edge_split))
|
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
|
|
/* Check if it's worth applying the partial redundancy elimination. */
|
2018-12-28 15:30:48 +00:00
|
|
|
|
if (ok_count.to_gcov_type ()
|
2022-10-27 18:55:19 +00:00
|
|
|
|
< param_gcse_after_reload_partial_fraction * not_ok_count.to_gcov_type ())
|
2012-03-27 23:13:14 +00:00
|
|
|
|
goto cleanup;
|
2019-06-02 15:48:37 +00:00
|
|
|
|
|
|
|
|
|
gcov_type threshold;
|
|
|
|
|
#if (GCC_VERSION >= 5000)
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (__builtin_mul_overflow (param_gcse_after_reload_critical_fraction,
|
2019-06-02 15:48:37 +00:00
|
|
|
|
critical_count.to_gcov_type (), &threshold))
|
|
|
|
|
threshold = profile_count::max_count;
|
|
|
|
|
#else
|
|
|
|
|
threshold
|
2022-10-27 18:55:19 +00:00
|
|
|
|
= (param_gcse_after_reload_critical_fraction
|
|
|
|
|
* critical_count.to_gcov_type ());
|
2019-06-02 15:48:37 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (ok_count.to_gcov_type () < threshold)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
|
|
/* Generate moves to the loaded register from where
|
|
|
|
|
the memory is available. */
|
|
|
|
|
for (occr = avail_occrs; occr; occr = occr->next)
|
|
|
|
|
{
|
|
|
|
|
avail_insn = occr->insn;
|
|
|
|
|
pred = occr->pred;
|
|
|
|
|
/* Set avail_reg to be the register having the value of the
|
|
|
|
|
memory. */
|
|
|
|
|
avail_reg = get_avail_load_store_reg (avail_insn);
|
|
|
|
|
gcc_assert (avail_reg);
|
|
|
|
|
|
|
|
|
|
insert_insn_on_edge (gen_move_insn (copy_rtx (dest),
|
|
|
|
|
copy_rtx (avail_reg)),
|
|
|
|
|
pred);
|
|
|
|
|
stats.moves_inserted++;
|
|
|
|
|
|
|
|
|
|
if (dump_file)
|
|
|
|
|
fprintf (dump_file,
|
|
|
|
|
"generating move from %d to %d on edge from %d to %d\n",
|
|
|
|
|
REGNO (avail_reg),
|
|
|
|
|
REGNO (dest),
|
|
|
|
|
pred->src->index,
|
|
|
|
|
pred->dest->index);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Regenerate loads where the memory is unavailable. */
|
|
|
|
|
for (unoccr = unavail_occrs; unoccr; unoccr = unoccr->next)
|
|
|
|
|
{
|
|
|
|
|
pred = unoccr->pred;
|
|
|
|
|
insert_insn_on_edge (copy_insn (PATTERN (insn)), pred);
|
|
|
|
|
stats.copies_inserted++;
|
|
|
|
|
|
|
|
|
|
if (dump_file)
|
|
|
|
|
{
|
|
|
|
|
fprintf (dump_file,
|
|
|
|
|
"generating on edge from %d to %d a copy of load: ",
|
|
|
|
|
pred->src->index,
|
|
|
|
|
pred->dest->index);
|
|
|
|
|
print_rtl (dump_file, PATTERN (insn));
|
|
|
|
|
fprintf (dump_file, "\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Delete the insn if it is not available in this block and mark it
|
|
|
|
|
for deletion if it is available. If insn is available it may help
|
|
|
|
|
discover additional redundancies, so mark it for later deletion. */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
for (a_occr = get_bb_avail_insn (bb, expr->avail_occr, expr->bitmap_index);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
a_occr && (a_occr->insn != insn);
|
2015-08-28 15:33:40 +00:00
|
|
|
|
a_occr = get_bb_avail_insn (bb, a_occr->next, expr->bitmap_index))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
if (!a_occr)
|
|
|
|
|
{
|
|
|
|
|
stats.insns_deleted++;
|
|
|
|
|
|
|
|
|
|
if (dump_file)
|
|
|
|
|
{
|
|
|
|
|
fprintf (dump_file, "deleting insn:\n");
|
|
|
|
|
print_rtl_single (dump_file, insn);
|
|
|
|
|
fprintf (dump_file, "\n");
|
|
|
|
|
}
|
|
|
|
|
delete_insn (insn);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
a_occr->deleted_p = 1;
|
|
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
|
if (rollback_unoccr)
|
|
|
|
|
obstack_free (&unoccr_obstack, rollback_unoccr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Performing the redundancy elimination as described before. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
eliminate_partially_redundant_loads (void)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
rtx_insn *insn;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
basic_block bb;
|
|
|
|
|
|
|
|
|
|
/* Note we start at block 1. */
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
|
2012-03-27 23:13:14 +00:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
FOR_BB_BETWEEN (bb,
|
2014-09-21 17:33:12 +00:00
|
|
|
|
ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb->next_bb,
|
|
|
|
|
EXIT_BLOCK_PTR_FOR_FN (cfun),
|
2012-03-27 23:13:14 +00:00
|
|
|
|
next_bb)
|
|
|
|
|
{
|
|
|
|
|
/* Don't try anything on basic blocks with strange predecessors. */
|
|
|
|
|
if (! bb_has_well_behaved_predecessors (bb))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* Do not try anything on cold basic blocks. */
|
|
|
|
|
if (optimize_bb_for_size_p (bb))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* Reset the table of things changed since the start of the current
|
|
|
|
|
basic block. */
|
|
|
|
|
reset_opr_set_tables ();
|
|
|
|
|
|
|
|
|
|
/* Look at all insns in the current basic block and see if there are
|
|
|
|
|
any loads in it that we can record. */
|
|
|
|
|
FOR_BB_INSNS (bb, insn)
|
|
|
|
|
{
|
|
|
|
|
/* Is it a load - of the form (set (reg) (mem))? */
|
|
|
|
|
if (NONJUMP_INSN_P (insn)
|
|
|
|
|
&& GET_CODE (PATTERN (insn)) == SET
|
|
|
|
|
&& REG_P (SET_DEST (PATTERN (insn)))
|
|
|
|
|
&& MEM_P (SET_SRC (PATTERN (insn))))
|
|
|
|
|
{
|
|
|
|
|
rtx pat = PATTERN (insn);
|
|
|
|
|
rtx src = SET_SRC (pat);
|
|
|
|
|
struct expr *expr;
|
|
|
|
|
|
|
|
|
|
if (!MEM_VOLATILE_P (src)
|
|
|
|
|
&& GET_MODE (src) != BLKmode
|
|
|
|
|
&& general_operand (src, GET_MODE (src))
|
|
|
|
|
/* Are the operands unchanged since the start of the
|
|
|
|
|
block? */
|
|
|
|
|
&& oprs_unchanged_p (src, insn, false)
|
|
|
|
|
&& !(cfun->can_throw_non_call_exceptions && may_trap_p (src))
|
|
|
|
|
&& !side_effects_p (src)
|
|
|
|
|
/* Is the expression recorded? */
|
|
|
|
|
&& (expr = lookup_expr_in_table (src)) != NULL)
|
|
|
|
|
{
|
|
|
|
|
/* We now have a load (insn) and an available memory at
|
|
|
|
|
its BB start (expr). Try to remove the loads if it is
|
|
|
|
|
redundant. */
|
|
|
|
|
eliminate_partially_redundant_load (bb, insn, expr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Keep track of everything modified by this insn, so that we
|
|
|
|
|
know what has been modified since the start of the current
|
|
|
|
|
basic block. */
|
|
|
|
|
if (INSN_P (insn))
|
|
|
|
|
record_opr_changes (insn);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
commit_edge_insertions ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Go over the expression hash table and delete insns that were
|
|
|
|
|
marked for later deletion. */
|
|
|
|
|
|
|
|
|
|
/* This helper is called via htab_traverse. */
|
2014-09-21 17:33:12 +00:00
|
|
|
|
int
|
|
|
|
|
delete_redundant_insns_1 (expr **slot, void *data ATTRIBUTE_UNUSED)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
2014-09-21 17:33:12 +00:00
|
|
|
|
struct expr *exprs = *slot;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
struct occr *occr;
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
for (occr = exprs->avail_occr; occr != NULL; occr = occr->next)
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
|
|
|
|
if (occr->deleted_p && dbg_cnt (gcse2_delete))
|
|
|
|
|
{
|
|
|
|
|
delete_insn (occr->insn);
|
|
|
|
|
stats.insns_deleted++;
|
|
|
|
|
|
|
|
|
|
if (dump_file)
|
|
|
|
|
{
|
|
|
|
|
fprintf (dump_file, "deleting insn:\n");
|
|
|
|
|
print_rtl_single (dump_file, occr->insn);
|
|
|
|
|
fprintf (dump_file, "\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
delete_redundant_insns (void)
|
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
expr_table->traverse <void *, delete_redundant_insns_1> (NULL);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
if (dump_file)
|
|
|
|
|
fprintf (dump_file, "\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Main entry point of the GCSE after reload - clean some redundant loads
|
|
|
|
|
due to spilling. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED)
|
|
|
|
|
{
|
2022-10-27 18:55:19 +00:00
|
|
|
|
/* Disable computing transparentness if it is too expensive. */
|
|
|
|
|
bool do_transp
|
|
|
|
|
= !gcse_or_cprop_is_too_expensive (_("using simple load CSE after register "
|
|
|
|
|
"allocation"));
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
memset (&stats, 0, sizeof (stats));
|
|
|
|
|
|
|
|
|
|
/* Allocate memory for this pass.
|
|
|
|
|
Also computes and initializes the insns' CUIDs. */
|
|
|
|
|
alloc_mem ();
|
|
|
|
|
|
|
|
|
|
/* We need alias analysis. */
|
|
|
|
|
init_alias_analysis ();
|
|
|
|
|
|
|
|
|
|
compute_hash_table ();
|
|
|
|
|
|
|
|
|
|
if (dump_file)
|
|
|
|
|
dump_hash_table (dump_file);
|
|
|
|
|
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (!expr_table->is_empty ())
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
2015-08-28 15:33:40 +00:00
|
|
|
|
/* Knowing which MEMs are transparent through a block can signifiantly
|
|
|
|
|
increase the number of redundant loads found. So compute transparency
|
|
|
|
|
information for each memory expression in the hash table. */
|
|
|
|
|
df_analyze ();
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (do_transp)
|
|
|
|
|
{
|
|
|
|
|
/* This cannot be part of the normal allocation routine because
|
|
|
|
|
we have to know the number of elements in the hash table. */
|
|
|
|
|
transp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
|
|
|
|
|
expr_table->elements ());
|
|
|
|
|
bitmap_vector_ones (transp, last_basic_block_for_fn (cfun));
|
|
|
|
|
expr_table->traverse <FILE *, compute_expr_transp> (dump_file);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
transp = NULL;
|
2012-03-27 23:13:14 +00:00
|
|
|
|
eliminate_partially_redundant_loads ();
|
|
|
|
|
delete_redundant_insns ();
|
2022-10-27 18:55:19 +00:00
|
|
|
|
if (do_transp)
|
|
|
|
|
sbitmap_vector_free (transp);
|
2012-03-27 23:13:14 +00:00
|
|
|
|
|
|
|
|
|
if (dump_file)
|
|
|
|
|
{
|
|
|
|
|
fprintf (dump_file, "GCSE AFTER RELOAD stats:\n");
|
|
|
|
|
fprintf (dump_file, "copies inserted: %d\n", stats.copies_inserted);
|
|
|
|
|
fprintf (dump_file, "moves inserted: %d\n", stats.moves_inserted);
|
|
|
|
|
fprintf (dump_file, "insns deleted: %d\n", stats.insns_deleted);
|
|
|
|
|
fprintf (dump_file, "\n\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
statistics_counter_event (cfun, "copies inserted",
|
|
|
|
|
stats.copies_inserted);
|
|
|
|
|
statistics_counter_event (cfun, "moves inserted",
|
|
|
|
|
stats.moves_inserted);
|
|
|
|
|
statistics_counter_event (cfun, "insns deleted",
|
|
|
|
|
stats.insns_deleted);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We are finished with alias. */
|
|
|
|
|
end_alias_analysis ();
|
|
|
|
|
|
|
|
|
|
free_mem ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
|
rest_of_handle_gcse2 (void)
|
|
|
|
|
{
|
|
|
|
|
gcse_after_reload_main (get_insns ());
|
|
|
|
|
rebuild_jump_labels (get_insns ());
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-21 17:33:12 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
const pass_data pass_data_gcse2 =
|
2012-03-27 23:13:14 +00:00
|
|
|
|
{
|
2014-09-21 17:33:12 +00:00
|
|
|
|
RTL_PASS, /* type */
|
|
|
|
|
"gcse2", /* name */
|
|
|
|
|
OPTGROUP_NONE, /* optinfo_flags */
|
|
|
|
|
TV_GCSE_AFTER_RELOAD, /* tv_id */
|
|
|
|
|
0, /* properties_required */
|
|
|
|
|
0, /* properties_provided */
|
|
|
|
|
0, /* properties_destroyed */
|
|
|
|
|
0, /* todo_flags_start */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
0, /* todo_flags_finish */
|
2012-03-27 23:13:14 +00:00
|
|
|
|
};
|
2014-09-21 17:33:12 +00:00
|
|
|
|
|
|
|
|
|
class pass_gcse2 : public rtl_opt_pass
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
pass_gcse2 (gcc::context *ctxt)
|
|
|
|
|
: rtl_opt_pass (pass_data_gcse2, ctxt)
|
|
|
|
|
{}
|
|
|
|
|
|
|
|
|
|
/* opt_pass methods: */
|
2015-08-28 15:33:40 +00:00
|
|
|
|
virtual bool gate (function *fun)
|
|
|
|
|
{
|
|
|
|
|
return (optimize > 0 && flag_gcse_after_reload
|
|
|
|
|
&& optimize_function_for_speed_p (fun));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
virtual unsigned int execute (function *) { return rest_of_handle_gcse2 (); }
|
2014-09-21 17:33:12 +00:00
|
|
|
|
|
|
|
|
|
}; // class pass_gcse2
|
|
|
|
|
|
|
|
|
|
} // anon namespace
|
|
|
|
|
|
|
|
|
|
rtl_opt_pass *
|
|
|
|
|
make_pass_gcse2 (gcc::context *ctxt)
|
|
|
|
|
{
|
|
|
|
|
return new pass_gcse2 (ctxt);
|
|
|
|
|
}
|