/* Common subexpression elimination for GNU compiler.
- Copyright (C) 1987, 88, 89, 92-7, 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998
+ 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "expr.h"
#include "toplev.h"
#include "output.h"
-#include "hashtab.h"
#include "ggc.h"
/* The basic idea of common subexpression elimination is to go
optimizer after CSE to delete the unreachable code.
We use two data structures to record the equivalent expressions:
- a hash table for most expressions, and several vectors together
- with "quantity numbers" to record equivalent (pseudo) registers.
+ a hash table for most expressions, and a vector of "quantity
+ numbers" to record equivalent (pseudo) registers.
The use of the special data structure for registers is desirable
because it is faster. It is possible because registers references
All real quantity numbers are greater than or equal to `max_reg'.
If register N has not been assigned a quantity, reg_qty[N] will equal N.
- Quantity numbers below `max_reg' do not exist and none of the `qty_...'
- variables should be referenced with an index below `max_reg'.
+ Quantity numbers below `max_reg' do not exist and none of the `qty_table'
+ entries should be referenced with an index below `max_reg'.
We also maintain a bidirectional chain of registers for each
- quantity number. `qty_first_reg', `qty_last_reg',
- `reg_next_eqv' and `reg_prev_eqv' hold these chains.
+ quantity number. The `qty_table` members `first_reg' and `last_reg',
+ and `reg_eqv_table' members `next' and `prev' hold these chains.
The first register in a chain is the one whose lifespan is least local.
Among equals, it is the one that was seen first.
We replace any equivalent register with that one.
If two registers have the same quantity number, it must be true that
- REG expressions with `qty_mode' must be in the hash table for both
+ REG expressions with qty_table `mode' must be in the hash table for both
registers and must be in the same class.
The converse is not true. Since hard registers may be referenced in
Constants and quantity numbers
When a quantity has a known constant value, that value is stored
- in the appropriate element of qty_const. This is in addition to
+ in the appropriate qty_table `const_rtx'. This is in addition to
putting the constant in the hash table as is usual for non-regs.
Whether a reg or a constant is preferred is determined by the configuration
event, expressions containing constants can be simplified, by fold_rtx.
When a quantity has a known nearly constant value (such as an address
- of a stack slot), that value is stored in the appropriate element
- of qty_const.
+ of a stack slot), that value is stored in the appropriate qty_table
+ `const_rtx'.
Integer constants don't have a machine mode. However, cse
determines the intended machine mode from the destination
currently have equivalent values.
Register references in an expression are canonicalized before hashing
- the expression. This is done using `reg_qty' and `qty_first_reg'.
+ the expression. This is done using `reg_qty' and qty_table `first_reg'.
The hash code of a register reference is computed using the quantity
number, not the register number.
static int max_insn_uid;
-/* Length of vectors indexed by quantity number.
- We know in advance we will not need a quantity number this big. */
+/* Length of qty_table vector. We know in advance we will not need
+ a quantity number this big. */
static int max_qty;
static int next_qty;
-/* Indexed by quantity number, gives the first (or last) register
- in the chain of registers that currently contain this quantity. */
+/* Per-qty information tracking.
-static int *qty_first_reg;
-static int *qty_last_reg;
+ `first_reg' and `last_reg' track the head and tail of the
+ chain of registers which currently contain this quantity.
-/* Index by quantity number, gives the mode of the quantity. */
+ `mode' contains the machine mode of this quantity.
-static enum machine_mode *qty_mode;
+ `const_rtx' holds the rtx of the constant value of this
+ quantity, if known. A summations of the frame/arg pointer
+ and a constant can also be entered here. When this holds
+ a known value, `const_insn' is the insn which stored the
+ constant value.
-/* Indexed by quantity number, gives the rtx of the constant value of the
- quantity, or zero if it does not have a known value.
- A sum of the frame pointer (or arg pointer) plus a constant
- can also be entered here. */
+ `comparison_{code,const,qty}' are used to track when a
+ comparison between a quantity and some constant or register has
+ been passed. In such a case, we know the results of the comparison
+ in case we see it again. These members record a comparison that
+ is known to be true. `comparison_code' holds the rtx code of such
+ a comparison, else it is set to UNKNOWN and the other two
+ comparison members are undefined. `comparison_const' holds
+ the constant being compared against, or zero if the comparison
+ is not against a constant. `comparison_qty' holds the quantity
+ being compared against when the result is known. If the comparison
+ is not with a register, `comparison_qty' is -1. */
-static rtx *qty_const;
-
-/* Indexed by qty number, gives the insn that stored the constant value
- recorded in `qty_const'. */
-
-static rtx *qty_const_insn;
-
-/* The next three variables are used to track when a comparison between a
- quantity and some constant or register has been passed. In that case, we
- know the results of the comparison in case we see it again. These variables
- record a comparison that is known to be true. */
-
-/* Indexed by qty number, gives the rtx code of a comparison with a known
- result involving this quantity. If none, it is UNKNOWN. */
-static enum rtx_code *qty_comparison_code;
-
-/* Indexed by qty number, gives the constant being compared against in a
- comparison of known result. If no such comparison, it is undefined.
- If the comparison is not with a constant, it is zero. */
-
-static rtx *qty_comparison_const;
-
-/* Indexed by qty number, gives the quantity being compared against in a
- comparison of known result. If no such comparison, if it undefined.
- If the comparison is not with a register, it is -1. */
+struct qty_table_elem
+{
+ rtx const_rtx;
+ rtx const_insn;
+ rtx comparison_const;
+ int comparison_qty;
+ unsigned int first_reg, last_reg;
+ enum machine_mode mode;
+ enum rtx_code comparison_code;
+};
-static int *qty_comparison_qty;
+/* The table of all qtys, indexed by qty number. */
+static struct qty_table_elem *qty_table;
#ifdef HAVE_cc0
/* For machines that have a CC0, we do not record its value in the hash
Or -1 if this register is at the end of the chain.
- If reg_qty[N] == N, reg_next_eqv[N] is undefined. */
+ If reg_qty[N] == N, reg_eqv_table[N].next is undefined. */
-static int *reg_next_eqv;
-static int *reg_prev_eqv;
+/* Per-register equivalence chain. */
+struct reg_eqv_elem
+{
+ int next, prev;
+};
+
+/* The table of all register equivalence chains. */
+static struct reg_eqv_elem *reg_eqv_table;
struct cse_reg_info
{
- /* The number of times the register has been altered in the current
- basic block. */
- int reg_tick;
+ /* Next in hash chain. */
+ struct cse_reg_info *hash_next;
/* The next cse_reg_info structure in the free or used list. */
struct cse_reg_info *next;
+ /* Search key */
+ unsigned int regno;
+
+ /* The quantity number of the register's current contents. */
+ int reg_qty;
+
+ /* The number of times the register has been altered in the current
+ basic block. */
+ int reg_tick;
+
/* The REG_TICK value at which rtx's containing this register are
valid in the hash table. If this does not equal the current
reg_tick value, such expressions existing in the hash table are
invalid. */
int reg_in_table;
-
- /* The quantity number of the register's current contents. */
- int reg_qty;
-
- /* Search key */
- int regno;
};
/* A free list of cse_reg_info entries. */
static struct cse_reg_info *cse_reg_info_used_list_end;
/* A mapping from registers to cse_reg_info data structures. */
-static hash_table_t cse_reg_info_tree;
+#define REGHASH_SHIFT 7
+#define REGHASH_SIZE (1 << REGHASH_SHIFT)
+#define REGHASH_MASK (REGHASH_SIZE - 1)
+static struct cse_reg_info *reg_hash[REGHASH_SIZE];
+
+#define REGHASH_FN(REGNO) \
+ (((REGNO) ^ ((REGNO) >> REGHASH_SHIFT)) & REGHASH_MASK)
/* The last lookup we did into the cse_reg_info_tree. This allows us
to cache repeated lookups. */
-static int cached_regno;
+static unsigned int cached_regno;
static struct cse_reg_info *cached_cse_reg_info;
/* A HARD_REG_SET containing all the hard registers for which there is
#define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
+/* Nonzero if this pass has made changes, and therefore it's
+ worthwhile to run the garbage collector. */
+
+static int cse_altered;
+
/* Nonzero if cse has altered conditional jump insns
in such a way that jump optimization should be redone. */
each recording one expression's information.
That expression is in the `exp' field.
+ The canon_exp field contains a canonical (from the point of view of
+ alias analysis) version of the `exp' field.
+
Those elements with the same hash code are chained in both directions
through the `next_same_hash' and `prev_same_hash' fields.
struct table_elt
{
rtx exp;
+ rtx canon_exp;
struct table_elt *next_same_hash;
struct table_elt *prev_same_hash;
struct table_elt *next_same_value;
/* We don't want a lot of buckets, because we rarely have very many
things stored in the hash table, and a lot of buckets slows
down a lot of loops that happen frequently. */
-#define NBUCKETS 31
+#define HASH_SHIFT 5
+#define HASH_SIZE (1 << HASH_SHIFT)
+#define HASH_MASK (HASH_SIZE - 1)
/* Compute hash code of X in mode M. Special-case case where X is a pseudo
register (hard registers may require `do_not_record' to be set). */
#define HASH(X, M) \
- (GET_CODE (X) == REG && REGNO (X) >= FIRST_PSEUDO_REGISTER \
- ? (((unsigned) REG << 7) + (unsigned) REG_QTY (REGNO (X))) % NBUCKETS \
- : canon_hash (X, M) % NBUCKETS)
+ ((GET_CODE (X) == REG && REGNO (X) >= FIRST_PSEUDO_REGISTER \
+ ? (((unsigned) REG << 7) + (unsigned) REG_QTY (REGNO (X))) \
+ : canon_hash (X, M)) & HASH_MASK)
/* Determine whether register number N is considered a fixed register for CSE.
It is desirable to replace other regs with fixed regs, to reduce need for
non-fixed hard regs.
- A reg wins if it is either the frame pointer or designated as fixed,
- but not if it is an overlapping register. */
-#ifdef OVERLAPPING_REGNO_P
-#define FIXED_REGNO_P(N) \
- (((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
- || fixed_regs[N] || global_regs[N]) \
- && ! OVERLAPPING_REGNO_P ((N)))
-#else
+ A reg wins if it is either the frame pointer or designated as fixed. */
#define FIXED_REGNO_P(N) \
((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
|| fixed_regs[N] || global_regs[N])
-#endif
/* Compute cost of X, as stored in the `cost' field of a table_elt. Fixed
hard registers and pointers into the frame are the cheapest with a cost
#define REG_QTY(N) ((GET_CSE_REG_INFO (N))->reg_qty)
/* Determine if the quantity number for register X represents a valid index
- into the `qty_...' variables. */
+ into the qty_table. */
-#define REGNO_QTY_VALID_P(N) (REG_QTY (N) != (N))
+#define REGNO_QTY_VALID_P(N) (REG_QTY (N) != (int) (N))
#ifdef ADDRESS_COST
/* The ADDRESS_COST macro does not deal with ADDRESSOF nodes. But,
? -1 : ADDRESS_COST(RTX))
#endif
-static struct table_elt *table[NBUCKETS];
+static struct table_elt *table[HASH_SIZE];
/* Chain of `struct table_elt's made so far for this function
but currently removed from the table. */
|| XEXP (X, 0) == virtual_outgoing_args_rtx)) \
|| GET_CODE (X) == ADDRESSOF)
-static int notreg_cost PROTO((rtx));
-static void new_basic_block PROTO((void));
-static void make_new_qty PROTO((int));
-static void make_regs_eqv PROTO((int, int));
-static void delete_reg_equiv PROTO((int));
-static int mention_regs PROTO((rtx));
-static int insert_regs PROTO((rtx, struct table_elt *, int));
-static void free_element PROTO((struct table_elt *));
-static void remove_from_table PROTO((struct table_elt *, unsigned));
-static struct table_elt *get_element PROTO((void));
-static struct table_elt *lookup PROTO((rtx, unsigned, enum machine_mode)),
- *lookup_for_remove PROTO((rtx, unsigned, enum machine_mode));
-static rtx lookup_as_function PROTO((rtx, enum rtx_code));
-static struct table_elt *insert PROTO((rtx, struct table_elt *, unsigned,
- enum machine_mode));
-static void merge_equiv_classes PROTO((struct table_elt *,
- struct table_elt *));
-static void invalidate PROTO((rtx, enum machine_mode));
-static int cse_rtx_varies_p PROTO((rtx));
-static void remove_invalid_refs PROTO((int));
-static void remove_invalid_subreg_refs PROTO((int, int, enum machine_mode));
-static void rehash_using_reg PROTO((rtx));
-static void invalidate_memory PROTO((void));
-static void invalidate_for_call PROTO((void));
-static rtx use_related_value PROTO((rtx, struct table_elt *));
-static unsigned canon_hash PROTO((rtx, enum machine_mode));
-static unsigned safe_hash PROTO((rtx, enum machine_mode));
-static int exp_equiv_p PROTO((rtx, rtx, int, int));
-static void set_nonvarying_address_components PROTO((rtx, int, rtx *,
- HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-static int refers_to_p PROTO((rtx, rtx));
-static rtx canon_reg PROTO((rtx, rtx));
-static void find_best_addr PROTO((rtx, rtx *));
-static enum rtx_code find_comparison_args PROTO((enum rtx_code, rtx *, rtx *,
- enum machine_mode *,
- enum machine_mode *));
-static rtx fold_rtx PROTO((rtx, rtx));
-static rtx equiv_constant PROTO((rtx));
-static void record_jump_equiv PROTO((rtx, int));
-static void record_jump_cond PROTO((enum rtx_code, enum machine_mode,
- rtx, rtx, int));
-static void cse_insn PROTO((rtx, rtx));
-#ifdef AUTO_INC_DEC
-static int addr_affects_sp_p PROTO((rtx));
-#endif
-static void invalidate_from_clobbers PROTO((rtx));
-static rtx cse_process_notes PROTO((rtx, rtx));
-static void cse_around_loop PROTO((rtx));
-static void invalidate_skipped_set PROTO((rtx, rtx, void *));
-static void invalidate_skipped_block PROTO((rtx));
-static void cse_check_loop_start PROTO((rtx, rtx, void *));
-static void cse_set_around_loop PROTO((rtx, rtx, rtx));
-static rtx cse_basic_block PROTO((rtx, rtx, struct branch_path *, int));
-static void count_reg_usage PROTO((rtx, int *, rtx, int));
-extern void dump_class PROTO((struct table_elt*));
-static struct cse_reg_info* get_cse_reg_info PROTO((int));
-static unsigned int hash_cse_reg_info PROTO((hash_table_entry_t));
-static int cse_reg_info_equal_p PROTO((hash_table_entry_t,
- hash_table_entry_t));
-
-static void flush_hash_table PROTO((void));
+static int notreg_cost PARAMS ((rtx));
+static void new_basic_block PARAMS ((void));
+static void make_new_qty PARAMS ((unsigned int, enum machine_mode));
+static void make_regs_eqv PARAMS ((unsigned int, unsigned int));
+static void delete_reg_equiv PARAMS ((unsigned int));
+static int mention_regs PARAMS ((rtx));
+static int insert_regs PARAMS ((rtx, struct table_elt *, int));
+static void remove_from_table PARAMS ((struct table_elt *, unsigned));
+static struct table_elt *lookup PARAMS ((rtx, unsigned, enum machine_mode)),
+ *lookup_for_remove PARAMS ((rtx, unsigned, enum machine_mode));
+static rtx lookup_as_function PARAMS ((rtx, enum rtx_code));
+static struct table_elt *insert PARAMS ((rtx, struct table_elt *, unsigned,
+ enum machine_mode));
+static void merge_equiv_classes PARAMS ((struct table_elt *,
+ struct table_elt *));
+static void invalidate PARAMS ((rtx, enum machine_mode));
+static int cse_rtx_varies_p PARAMS ((rtx));
+static void remove_invalid_refs PARAMS ((unsigned int));
+static void remove_invalid_subreg_refs PARAMS ((unsigned int, unsigned int,
+ enum machine_mode));
+static void rehash_using_reg PARAMS ((rtx));
+static void invalidate_memory PARAMS ((void));
+static void invalidate_for_call PARAMS ((void));
+static rtx use_related_value PARAMS ((rtx, struct table_elt *));
+static unsigned canon_hash PARAMS ((rtx, enum machine_mode));
+static unsigned safe_hash PARAMS ((rtx, enum machine_mode));
+static int exp_equiv_p PARAMS ((rtx, rtx, int, int));
+static rtx canon_reg PARAMS ((rtx, rtx));
+static void find_best_addr PARAMS ((rtx, rtx *));
+static enum rtx_code find_comparison_args PARAMS ((enum rtx_code, rtx *, rtx *,
+ enum machine_mode *,
+ enum machine_mode *));
+static rtx fold_rtx PARAMS ((rtx, rtx));
+static rtx equiv_constant PARAMS ((rtx));
+static void record_jump_equiv PARAMS ((rtx, int));
+static void record_jump_cond PARAMS ((enum rtx_code, enum machine_mode,
+ rtx, rtx, int));
+static void cse_insn PARAMS ((rtx, rtx));
+static int addr_affects_sp_p PARAMS ((rtx));
+static void invalidate_from_clobbers PARAMS ((rtx));
+static rtx cse_process_notes PARAMS ((rtx, rtx));
+static void cse_around_loop PARAMS ((rtx));
+static void invalidate_skipped_set PARAMS ((rtx, rtx, void *));
+static void invalidate_skipped_block PARAMS ((rtx));
+static void cse_check_loop_start PARAMS ((rtx, rtx, void *));
+static void cse_set_around_loop PARAMS ((rtx, rtx, rtx));
+static rtx cse_basic_block PARAMS ((rtx, rtx, struct branch_path *, int));
+static void count_reg_usage PARAMS ((rtx, int *, rtx, int));
+extern void dump_class PARAMS ((struct table_elt*));
+static struct cse_reg_info * get_cse_reg_info PARAMS ((unsigned int));
+
+static void flush_hash_table PARAMS ((void));
\f
/* Dump the expressions in the equivalence class indicated by CLASSP.
This function is used only for debugging. */
}
}
-/* Return an estimate of the cost of computing rtx X.
- One use is in cse, to decide which expression to keep in the hash table.
- Another is in rtl generation, to pick the cheapest way to multiply.
- Other uses like the latter are expected in the future. */
-
/* Internal function, to compute cost when X is not a register; called
from COST macro to keep it simple. */
#define COSTS_N_INSNS(N) ((N) * 4 - 2)
+/* Return an estimate of the cost of computing rtx X.
+ One use is in cse, to decide which expression to keep in the hash table.
+ Another is in rtl generation, to pick the cheapest way to multiply.
+ Other uses like the latter are expected in the future. */
+
int
rtx_cost (x, outer_code)
rtx x;
\f
static struct cse_reg_info *
get_cse_reg_info (regno)
- int regno;
+ unsigned int regno;
{
- struct cse_reg_info *cri;
- struct cse_reg_info **entry;
- struct cse_reg_info temp;
-
- /* See if we already have this entry. */
- temp.regno = regno;
- entry = (struct cse_reg_info **) find_hash_table_entry (cse_reg_info_tree,
- &temp, TRUE);
-
- if (*entry)
- cri = *entry;
- else
+ struct cse_reg_info **hash_head = ®_hash[REGHASH_FN (regno)];
+ struct cse_reg_info *p;
+
+ for (p = *hash_head ; p != NULL; p = p->hash_next)
+ if (p->regno == regno)
+ break;
+
+ if (p == NULL)
{
/* Get a new cse_reg_info structure. */
- if (cse_reg_info_free_list)
+ if (cse_reg_info_free_list)
{
- cri = cse_reg_info_free_list;
- cse_reg_info_free_list = cri->next;
+ p = cse_reg_info_free_list;
+ cse_reg_info_free_list = p->next;
}
else
- cri = (struct cse_reg_info *) xmalloc (sizeof (struct cse_reg_info));
+ p = (struct cse_reg_info *) xmalloc (sizeof (struct cse_reg_info));
+
+ /* Insert into hash table. */
+ p->hash_next = *hash_head;
+ *hash_head = p;
/* Initialize it. */
- cri->reg_tick = 0;
- cri->reg_in_table = -1;
- cri->reg_qty = regno;
- cri->regno = regno;
- cri->next = cse_reg_info_used_list;
- cse_reg_info_used_list = cri;
+ p->reg_tick = 1;
+ p->reg_in_table = -1;
+ p->reg_qty = regno;
+ p->regno = regno;
+ p->next = cse_reg_info_used_list;
+ cse_reg_info_used_list = p;
if (!cse_reg_info_used_list_end)
- cse_reg_info_used_list_end = cri;
-
- *entry = cri;
+ cse_reg_info_used_list_end = p;
}
/* Cache this lookup; we tend to be looking up information about the
same register several times in a row. */
cached_regno = regno;
- cached_cse_reg_info = cri;
-
- return cri;
-}
+ cached_cse_reg_info = p;
-static unsigned int
-hash_cse_reg_info (el_ptr)
- hash_table_entry_t el_ptr;
-{
- return ((const struct cse_reg_info *) el_ptr)->regno;
-}
-
-static int
-cse_reg_info_equal_p (el_ptr1, el_ptr2)
- hash_table_entry_t el_ptr1;
- hash_table_entry_t el_ptr2;
-{
- return (((const struct cse_reg_info *) el_ptr1)->regno
- == ((const struct cse_reg_info *) el_ptr2)->regno);
+ return p;
}
/* Clear the hash table and initialize each register with its own quantity,
next_qty = max_reg;
- if (cse_reg_info_tree)
+ /* Clear out hash table state for this pass. */
+
+ bzero ((char *) reg_hash, sizeof reg_hash);
+
+ if (cse_reg_info_used_list)
{
- delete_hash_table (cse_reg_info_tree);
- if (cse_reg_info_used_list)
- {
- cse_reg_info_used_list_end->next = cse_reg_info_free_list;
- cse_reg_info_free_list = cse_reg_info_used_list;
- cse_reg_info_used_list = cse_reg_info_used_list_end = 0;
- }
- cached_cse_reg_info = 0;
+ cse_reg_info_used_list_end->next = cse_reg_info_free_list;
+ cse_reg_info_free_list = cse_reg_info_used_list;
+ cse_reg_info_used_list = cse_reg_info_used_list_end = 0;
}
-
- cse_reg_info_tree = create_hash_table (0, hash_cse_reg_info,
- cse_reg_info_equal_p);
+ cached_cse_reg_info = 0;
CLEAR_HARD_REG_SET (hard_regs_in_table);
/* The per-quantity values used to be initialized here, but it is
much faster to initialize each as it is made in `make_new_qty'. */
- for (i = 0; i < NBUCKETS; i++)
+ for (i = 0; i < HASH_SIZE; i++)
{
- register struct table_elt *this, *next;
- for (this = table[i]; this; this = next)
+ struct table_elt *first;
+
+ first = table[i];
+ if (first != NULL)
{
- next = this->next_same_hash;
- free_element (this);
+ struct table_elt *last = first;
+
+ table[i] = NULL;
+
+ while (last->next_same_hash != NULL)
+ last = last->next_same_hash;
+
+ /* Now relink this hash entire chain into
+ the free element list. */
+
+ last->next_same_hash = free_element_chain;
+ free_element_chain = first;
}
}
- bzero ((char *) table, sizeof table);
-
prev_insn = 0;
#ifdef HAVE_cc0
#endif
}
-/* Say that register REG contains a quantity not in any register before
- and initialize that quantity. */
+/* Say that register REG contains a quantity in mode MODE not in any
+ register before and initialize that quantity. */
static void
-make_new_qty (reg)
- register int reg;
+make_new_qty (reg, mode)
+ unsigned int reg;
+ enum machine_mode mode;
{
register int q;
+ register struct qty_table_elem *ent;
+ register struct reg_eqv_elem *eqv;
if (next_qty >= max_qty)
abort ();
q = REG_QTY (reg) = next_qty++;
- qty_first_reg[q] = reg;
- qty_last_reg[q] = reg;
- qty_const[q] = qty_const_insn[q] = 0;
- qty_comparison_code[q] = UNKNOWN;
-
- reg_next_eqv[reg] = reg_prev_eqv[reg] = -1;
+ ent = &qty_table[q];
+ ent->first_reg = reg;
+ ent->last_reg = reg;
+ ent->mode = mode;
+ ent->const_rtx = ent->const_insn = NULL_RTX;
+ ent->comparison_code = UNKNOWN;
+
+ eqv = ®_eqv_table[reg];
+ eqv->next = eqv->prev = -1;
}
/* Make reg NEW equivalent to reg OLD.
static void
make_regs_eqv (new, old)
- register int new, old;
+ unsigned int new, old;
{
- register int lastr, firstr;
- register int q = REG_QTY (old);
+ unsigned int lastr, firstr;
+ int q = REG_QTY (old);
+ struct qty_table_elem *ent;
+
+ ent = &qty_table[q];
/* Nothing should become eqv until it has a "non-invalid" qty number. */
if (! REGNO_QTY_VALID_P (old))
abort ();
REG_QTY (new) = q;
- firstr = qty_first_reg[q];
- lastr = qty_last_reg[q];
+ firstr = ent->first_reg;
+ lastr = ent->last_reg;
/* Prefer fixed hard registers to anything. Prefer pseudo regs to other
hard regs. Among pseudos, if NEW will live longer than any other reg
&& (uid_cuid[REGNO_LAST_UID (new)]
> uid_cuid[REGNO_LAST_UID (firstr)]))))))
{
- reg_prev_eqv[firstr] = new;
- reg_next_eqv[new] = firstr;
- reg_prev_eqv[new] = -1;
- qty_first_reg[q] = new;
+ reg_eqv_table[firstr].prev = new;
+ reg_eqv_table[new].next = firstr;
+ reg_eqv_table[new].prev = -1;
+ ent->first_reg = new;
}
else
{
Otherwise, insert before any non-fixed hard regs that are at the
end. Registers of class NO_REGS cannot be used as an
equivalent for anything. */
- while (lastr < FIRST_PSEUDO_REGISTER && reg_prev_eqv[lastr] >= 0
+ while (lastr < FIRST_PSEUDO_REGISTER && reg_eqv_table[lastr].prev >= 0
&& (REGNO_REG_CLASS (lastr) == NO_REGS || ! FIXED_REGNO_P (lastr))
&& new >= FIRST_PSEUDO_REGISTER)
- lastr = reg_prev_eqv[lastr];
- reg_next_eqv[new] = reg_next_eqv[lastr];
- if (reg_next_eqv[lastr] >= 0)
- reg_prev_eqv[reg_next_eqv[lastr]] = new;
+ lastr = reg_eqv_table[lastr].prev;
+ reg_eqv_table[new].next = reg_eqv_table[lastr].next;
+ if (reg_eqv_table[lastr].next >= 0)
+ reg_eqv_table[reg_eqv_table[lastr].next].prev = new;
else
- qty_last_reg[q] = new;
- reg_next_eqv[lastr] = new;
- reg_prev_eqv[new] = lastr;
+ qty_table[q].last_reg = new;
+ reg_eqv_table[lastr].next = new;
+ reg_eqv_table[new].prev = lastr;
}
}
static void
delete_reg_equiv (reg)
- register int reg;
+ unsigned int reg;
{
+ register struct qty_table_elem *ent;
register int q = REG_QTY (reg);
register int p, n;
/* If invalid, do nothing. */
- if (q == reg)
+ if (q == (int) reg)
return;
- p = reg_prev_eqv[reg];
- n = reg_next_eqv[reg];
+ ent = &qty_table[q];
+
+ p = reg_eqv_table[reg].prev;
+ n = reg_eqv_table[reg].next;
if (n != -1)
- reg_prev_eqv[n] = p;
+ reg_eqv_table[n].prev = p;
else
- qty_last_reg[q] = p;
+ ent->last_reg = p;
if (p != -1)
- reg_next_eqv[p] = n;
+ reg_eqv_table[p].next = n;
else
- qty_first_reg[q] = n;
+ ent->first_reg = n;
REG_QTY (reg) = reg;
}
code = GET_CODE (x);
if (code == REG)
{
- register int regno = REGNO (x);
- register int endregno
+ unsigned int regno = REGNO (x);
+ unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
: HARD_REGNO_NREGS (regno, GET_MODE (x)));
- int i;
+ unsigned int i;
for (i = regno; i < endregno; i++)
{
if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG
&& REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER)
{
- int i = REGNO (SUBREG_REG (x));
+ unsigned int i = REGNO (SUBREG_REG (x));
if (REG_IN_TABLE (i) >= 0 && REG_IN_TABLE (i) != REG_TICK (i))
{
{
if (GET_CODE (x) == REG)
{
- register int regno = REGNO (x);
+ unsigned int regno = REGNO (x);
+ int qty_valid;
/* If REGNO is in the equivalence table already but is of the
wrong mode for that equivalence, don't do anything here. */
- if (REGNO_QTY_VALID_P (regno)
- && qty_mode[REG_QTY (regno)] != GET_MODE (x))
- return 0;
+ qty_valid = REGNO_QTY_VALID_P (regno);
+ if (qty_valid)
+ {
+ struct qty_table_elem *ent = &qty_table[REG_QTY (regno)];
- if (modified || ! REGNO_QTY_VALID_P (regno))
+ if (ent->mode != GET_MODE (x))
+ return 0;
+ }
+
+ if (modified || ! qty_valid)
{
if (classp)
for (classp = classp->first_same_value;
return 1;
}
- make_new_qty (regno);
- qty_mode[REG_QTY (regno)] = GET_MODE (x);
+ make_new_qty (regno, GET_MODE (x));
return 1;
}
else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == REG
&& ! REGNO_QTY_VALID_P (REGNO (SUBREG_REG (x))))
{
- int regno = REGNO (SUBREG_REG (x));
+ unsigned int regno = REGNO (SUBREG_REG (x));
insert_regs (SUBREG_REG (x), NULL_PTR, 0);
/* Mention_regs checks if REG_TICK is exactly one larger than
\f
/* Look in or update the hash table. */
-/* Put the element ELT on the list of free elements. */
-
-static void
-free_element (elt)
- struct table_elt *elt;
-{
- elt->next_same_hash = free_element_chain;
- free_element_chain = elt;
-}
-
-/* Return an element that is free for use. */
-
-static struct table_elt *
-get_element ()
-{
- struct table_elt *elt = free_element_chain;
- if (elt)
- {
- free_element_chain = elt->next_same_hash;
- return elt;
- }
- n_elements_made++;
- return (struct table_elt *) oballoc (sizeof (struct table_elt));
-}
-
/* Remove table element ELT from use in the table.
HASH is its hash code, made using the HASH macro.
It's an argument because often that is known in advance
when two classes were merged by `merge_equiv_classes'. Search
for the hash bucket that it heads. This happens only very
rarely, so the cost is acceptable. */
- for (hash = 0; hash < NBUCKETS; hash++)
+ for (hash = 0; hash < HASH_SIZE; hash++)
if (table[hash] == elt)
table[hash] = next;
}
if (elt->related_value != 0 && elt->related_value != elt)
{
register struct table_elt *p = elt->related_value;
+
while (p->related_value != elt)
p = p->related_value;
p->related_value = elt->related_value;
p->related_value = 0;
}
- free_element (elt);
+ /* Now add it to the free element chain. */
+ elt->next_same_hash = free_element_chain;
+ free_element_chain = elt;
}
/* Look up X in the hash table and return its table element,
if (GET_CODE (x) == REG)
{
- int regno = REGNO (x);
+ unsigned int regno = REGNO (x);
+
/* Don't check the machine mode when comparing registers;
invalidating (REG:SI 0) also invalidates (REG:DF 0). */
for (p = table[hash]; p; p = p->next_same_hash)
rtx x;
enum rtx_code code;
{
- register struct table_elt *p = lookup (x, safe_hash (x, VOIDmode) % NBUCKETS,
- GET_MODE (x));
+ register struct table_elt *p
+ = lookup (x, safe_hash (x, VOIDmode) & HASH_MASK, GET_MODE (x));
+
/* If we are looking for a CONST_INT, the mode doesn't really matter, as
long as we are narrowing. So if we looked in vain for a mode narrower
than word_mode before, look for word_mode now. */
{
x = copy_rtx (x);
PUT_MODE (x, word_mode);
- p = lookup (x, safe_hash (x, VOIDmode) % NBUCKETS, word_mode);
+ p = lookup (x, safe_hash (x, VOIDmode) & HASH_MASK, word_mode);
}
if (p == 0)
return 0;
for (p = p->first_same_value; p; p = p->next_same_value)
- {
- if (GET_CODE (p->exp) == code
- /* Make sure this is a valid entry in the table. */
- && exp_equiv_p (p->exp, p->exp, 1, 0))
- return p->exp;
- }
+ if (GET_CODE (p->exp) == code
+ /* Make sure this is a valid entry in the table. */
+ && exp_equiv_p (p->exp, p->exp, 1, 0))
+ return p->exp;
return 0;
}
/* If X is a hard register, show it is being put in the table. */
if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
{
- int regno = REGNO (x);
- int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
- int i;
+ unsigned int regno = REGNO (x);
+ unsigned int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
+ unsigned int i;
for (i = regno; i < endregno; i++)
- SET_HARD_REG_BIT (hard_regs_in_table, i);
+ SET_HARD_REG_BIT (hard_regs_in_table, i);
}
/* If X is a label, show we recorded it. */
/* Put an element for X into the right hash bucket. */
- elt = get_element ();
+ elt = free_element_chain;
+ if (elt)
+ free_element_chain = elt->next_same_hash;
+ else
+ {
+ n_elements_made++;
+ elt = (struct table_elt *) oballoc (sizeof (struct table_elt));
+ }
+
elt->exp = x;
+ elt->canon_exp = NULL_RTX;
elt->cost = COST (x);
elt->next_same_value = 0;
elt->prev_same_value = 0;
/* Insert not at head of the class. */
/* Put it after the last element cheaper than X. */
register struct table_elt *p, *next;
+
for (p = classp; (next = p->next_same_value) && CHEAPER (next, elt);
p = next);
+
/* Put it after P and before NEXT. */
elt->next_same_value = next;
if (next)
next->prev_same_value = elt;
+
elt->prev_same_value = p;
p->next_same_value = elt;
elt->first_same_value = classp;
constant, we must check the entire class.
If this is a register that is already known equivalent to an insn,
- update `qty_const_insn' to show that `this_insn' is the latest
+ update the qtys `const_insn' to show that `this_insn' is the latest
insn making that quantity equivalent to the constant. */
if (elt->is_const && classp && GET_CODE (classp->exp) == REG
&& GET_CODE (x) != REG)
{
- qty_const[REG_QTY (REGNO (classp->exp))]
- = gen_lowpart_if_possible (qty_mode[REG_QTY (REGNO (classp->exp))], x);
- qty_const_insn[REG_QTY (REGNO (classp->exp))] = this_insn;
+ int exp_q = REG_QTY (REGNO (classp->exp));
+ struct qty_table_elem *exp_ent = &qty_table[exp_q];
+
+ exp_ent->const_rtx = gen_lowpart_if_possible (exp_ent->mode, x);
+ exp_ent->const_insn = this_insn;
}
- else if (GET_CODE (x) == REG && classp && ! qty_const[REG_QTY (REGNO (x))]
+ else if (GET_CODE (x) == REG
+ && classp
+ && ! qty_table[REG_QTY (REGNO (x))].const_rtx
&& ! elt->is_const)
{
register struct table_elt *p;
{
if (p->is_const && GET_CODE (p->exp) != REG)
{
- qty_const[REG_QTY (REGNO (x))]
+ int x_q = REG_QTY (REGNO (x));
+ struct qty_table_elem *x_ent = &qty_table[x_q];
+
+ x_ent->const_rtx
= gen_lowpart_if_possible (GET_MODE (x), p->exp);
- qty_const_insn[REG_QTY (REGNO (x))] = this_insn;
+ x_ent->const_insn = this_insn;
break;
}
}
}
- else if (GET_CODE (x) == REG && qty_const[REG_QTY (REGNO (x))]
- && GET_MODE (x) == qty_mode[REG_QTY (REGNO (x))])
- qty_const_insn[REG_QTY (REGNO (x))] = this_insn;
+ else if (GET_CODE (x) == REG
+ && qty_table[REG_QTY (REGNO (x))].const_rtx
+ && GET_MODE (x) == qty_table[REG_QTY (REGNO (x))].mode)
+ qty_table[REG_QTY (REGNO (x))].const_insn = this_insn;
/* If this is a constant with symbolic value,
and it has a term with an explicit integer value,
if (subexp != 0)
{
/* Get the integer-free subexpression in the hash table. */
- subhash = safe_hash (subexp, mode) % NBUCKETS;
+ subhash = safe_hash (subexp, mode) & HASH_MASK;
subelt = lookup (subexp, subhash, mode);
if (subelt == 0)
subelt = insert (subexp, NULL_PTR, subhash, mode);
for (elt = class2; elt; elt = next)
{
- unsigned hash;
+ unsigned int hash;
rtx exp = elt->exp;
enum machine_mode mode = elt->mode;
int i;
struct table_elt *p;
- for (i = 0; i < NBUCKETS; i++)
+ for (i = 0; i < HASH_SIZE; i++)
for (p = table[i]; p; p = table[i])
{
/* Note that invalidate can remove elements
through the qty number mechanism. Just change the qty number of
the register, mark it as invalid for expressions that refer to it,
and remove it itself. */
- register int regno = REGNO (x);
- register unsigned hash = HASH (x, GET_MODE (x));
+ unsigned int regno = REGNO (x);
+ unsigned int hash = HASH (x, GET_MODE (x));
/* Remove REGNO from any quantity list it might be on and indicate
that its value might have changed. If it is a pseudo, remove its
{
HOST_WIDE_INT in_table
= TEST_HARD_REG_BIT (hard_regs_in_table, regno);
- int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
- int tregno, tendregno;
+ unsigned int endregno
+ = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
+ unsigned int tregno, tendregno, rn;
register struct table_elt *p, *next;
CLEAR_HARD_REG_BIT (hard_regs_in_table, regno);
- for (i = regno + 1; i < endregno; i++)
+ for (rn = regno + 1; rn < endregno; rn++)
{
- in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, i);
- CLEAR_HARD_REG_BIT (hard_regs_in_table, i);
- delete_reg_equiv (i);
- REG_TICK (i)++;
+ in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, rn);
+ CLEAR_HARD_REG_BIT (hard_regs_in_table, rn);
+ delete_reg_equiv (rn);
+ REG_TICK (rn)++;
}
if (in_table)
- for (hash = 0; hash < NBUCKETS; hash++)
+ for (hash = 0; hash < HASH_SIZE; hash++)
for (p = table[hash]; p; p = next)
{
next = p->next_same_hash;
return;
case MEM:
+ /* Calculate the canonical version of X here so that
+ true_dependence doesn't generate new RTL for X on each call. */
+ x = canon_rtx (x);
+
/* Remove all hash table elements that refer to overlapping pieces of
memory. */
if (full_mode == VOIDmode)
full_mode = GET_MODE (x);
- for (i = 0; i < NBUCKETS; i++)
+ for (i = 0; i < HASH_SIZE; i++)
{
register struct table_elt *next;
for (p = table[i]; p; p = next)
{
next = p->next_same_hash;
- if (p->in_memory
- && (GET_CODE (p->exp) != MEM
- || true_dependence (x, full_mode, p->exp,
- cse_rtx_varies_p)))
- remove_from_table (p, i);
+ if (p->in_memory)
+ {
+ if (GET_CODE (p->exp) != MEM)
+ remove_from_table (p, i);
+ else
+ {
+ /* Just canonicalize the expression once;
+ otherwise each time we call invalidate
+ true_dependence will canonicalize the
+ expression again. */
+ if (!p->canon_exp)
+ p->canon_exp = canon_rtx (p->exp);
+ if (true_dependence (x, full_mode, p->canon_exp,
+ cse_rtx_varies_p))
+ remove_from_table (p, i);
+ }
+ }
}
}
return;
static void
remove_invalid_refs (regno)
- int regno;
+ unsigned int regno;
{
- register int i;
- register struct table_elt *p, *next;
+ unsigned int i;
+ struct table_elt *p, *next;
- for (i = 0; i < NBUCKETS; i++)
+ for (i = 0; i < HASH_SIZE; i++)
for (p = table[i]; p; p = next)
{
next = p->next_same_hash;
/* Likewise for a subreg with subreg_reg WORD and mode MODE. */
static void
remove_invalid_subreg_refs (regno, word, mode)
- int regno;
- int word;
+ unsigned int regno;
+ unsigned int word;
enum machine_mode mode;
{
- register int i;
- register struct table_elt *p, *next;
- int end = word + (GET_MODE_SIZE (mode) - 1) / UNITS_PER_WORD;
+ unsigned int i;
+ struct table_elt *p, *next;
+ unsigned int end = word + (GET_MODE_SIZE (mode) - 1) / UNITS_PER_WORD;
- for (i = 0; i < NBUCKETS; i++)
+ for (i = 0; i < HASH_SIZE; i++)
for (p = table[i]; p; p = next)
{
rtx exp;
If we find one and it is in the wrong hash chain, move it. We can skip
objects that are registers, since they are handled specially. */
- for (i = 0; i < NBUCKETS; i++)
+ for (i = 0; i < HASH_SIZE; i++)
for (p = table[i]; p; p = next)
{
next = p->next_same_hash;
if (GET_CODE (p->exp) != REG && reg_mentioned_p (x, p->exp)
&& exp_equiv_p (p->exp, p->exp, 1, 0)
- && i != (hash = safe_hash (p->exp, p->mode) % NBUCKETS))
+ && i != (hash = safe_hash (p->exp, p->mode) & HASH_MASK))
{
if (p->next_same_hash)
p->next_same_hash->prev_same_hash = p->prev_same_hash;
static void
invalidate_for_call ()
{
- int regno, endregno;
- int i;
+ unsigned int regno, endregno;
+ unsigned int i;
unsigned hash;
struct table_elt *p, *next;
int in_table = 0;
entry that overlaps a call-clobbered register. */
if (in_table)
- for (hash = 0; hash < NBUCKETS; hash++)
+ for (hash = 0; hash < HASH_SIZE; hash++)
for (p = table[hash]; p; p = next)
{
next = p->next_same_hash;
rtx subexp = get_related_value (x);
if (subexp != 0)
relt = lookup (subexp,
- safe_hash (subexp, GET_MODE (subexp)) % NBUCKETS,
+ safe_hash (subexp, GET_MODE (subexp)) & HASH_MASK,
GET_MODE (subexp));
}
{
case REG:
{
- register int regno = REGNO (x);
+ unsigned int regno = REGNO (x);
/* On some machines, we can't record any non-fixed hard register,
because extending its life will cause reload problems. We
do_not_record = 1;
return 0;
}
+
hash += ((unsigned) REG << 7) + (unsigned) REG_QTY (regno);
return hash;
}
hash += canon_hash (XVECEXP (x, i, j), 0);
else if (fmt[i] == 's')
{
- register unsigned char *p = (unsigned char *) XSTR (x, i);
+ register const unsigned char *p =
+ (const unsigned char *) XSTR (x, i);
+
if (p)
while (*p)
hash += *p++;
/* If X is a constant and Y is a register or vice versa, they may be
equivalent. We only have to validate if Y is a register. */
if (CONSTANT_P (x) && GET_CODE (y) == REG
- && REGNO_QTY_VALID_P (REGNO (y))
- && GET_MODE (y) == qty_mode[REG_QTY (REGNO (y))]
- && rtx_equal_p (x, qty_const[REG_QTY (REGNO (y))])
- && (! validate || REG_IN_TABLE (REGNO (y)) == REG_TICK (REGNO (y))))
- return 1;
+ && REGNO_QTY_VALID_P (REGNO (y)))
+ {
+ int y_q = REG_QTY (REGNO (y));
+ struct qty_table_elem *y_ent = &qty_table[y_q];
+
+ if (GET_MODE (y) == y_ent->mode
+ && rtx_equal_p (x, y_ent->const_rtx)
+ && (! validate || REG_IN_TABLE (REGNO (y)) == REG_TICK (REGNO (y))))
+ return 1;
+ }
if (CONSTANT_P (y) && code == REG
- && REGNO_QTY_VALID_P (REGNO (x))
- && GET_MODE (x) == qty_mode[REG_QTY (REGNO (x))]
- && rtx_equal_p (y, qty_const[REG_QTY (REGNO (x))]))
- return 1;
+ && REGNO_QTY_VALID_P (REGNO (x)))
+ {
+ int x_q = REG_QTY (REGNO (x));
+ struct qty_table_elem *x_ent = &qty_table[x_q];
+
+ if (GET_MODE (x) == x_ent->mode
+ && rtx_equal_p (y, x_ent->const_rtx))
+ return 1;
+ }
return 0;
}
{
case PC:
case CC0:
- return x == y;
-
case CONST_INT:
- return INTVAL (x) == INTVAL (y);
+ return x == y;
case LABEL_REF:
return XEXP (x, 0) == XEXP (y, 0);
case REG:
{
- int regno = REGNO (y);
- int endregno
+ unsigned int regno = REGNO (y);
+ unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
: HARD_REGNO_NREGS (regno, GET_MODE (y)));
- int i;
+ unsigned int i;
/* If the quantities are not the same, the expressions are not
equivalent. If there are and we are not to validate, they
return 1;
}
\f
-/* Return 1 iff any subexpression of X matches Y.
- Here we do not require that X or Y be valid (for registers referred to)
- for being in the hash table. */
-
-static int
-refers_to_p (x, y)
- rtx x, y;
-{
- register int i;
- register enum rtx_code code;
- register const char *fmt;
-
- repeat:
- if (x == y)
- return 1;
- if (x == 0 || y == 0)
- return 0;
-
- code = GET_CODE (x);
- /* If X as a whole has the same code as Y, they may match.
- If so, return 1. */
- if (code == GET_CODE (y))
- {
- if (exp_equiv_p (x, y, 0, 1))
- return 1;
- }
-
- /* X does not match, so try its subexpressions. */
-
- fmt = GET_RTX_FORMAT (code);
- for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
- if (fmt[i] == 'e')
- {
- if (i == 0)
- {
- x = XEXP (x, 0);
- goto repeat;
- }
- else
- if (refers_to_p (XEXP (x, i), y))
- return 1;
- }
- else if (fmt[i] == 'E')
- {
- int j;
- for (j = 0; j < XVECLEN (x, i); j++)
- if (refers_to_p (XVECEXP (x, i, j), y))
- return 1;
- }
-
- return 0;
-}
-\f
-/* Given ADDR and SIZE (a memory address, and the size of the memory reference),
- set PBASE, PSTART, and PEND which correspond to the base of the address,
- the starting offset, and ending offset respectively.
-
- ADDR is known to be a nonvarying address. */
-
-/* ??? Despite what the comments say, this function is in fact frequently
- passed varying addresses. This does not appear to cause any problems. */
-
-static void
-set_nonvarying_address_components (addr, size, pbase, pstart, pend)
- rtx addr;
- int size;
- rtx *pbase;
- HOST_WIDE_INT *pstart, *pend;
-{
- rtx base;
- HOST_WIDE_INT start, end;
-
- base = addr;
- start = 0;
- end = 0;
-
- if (flag_pic && GET_CODE (base) == PLUS
- && XEXP (base, 0) == pic_offset_table_rtx)
- base = XEXP (base, 1);
-
- /* Registers with nonvarying addresses usually have constant equivalents;
- but the frame pointer register is also possible. */
- if (GET_CODE (base) == REG
- && qty_const != 0
- && REGNO_QTY_VALID_P (REGNO (base))
- && qty_mode[REG_QTY (REGNO (base))] == GET_MODE (base)
- && qty_const[REG_QTY (REGNO (base))] != 0)
- base = qty_const[REG_QTY (REGNO (base))];
- else if (GET_CODE (base) == PLUS
- && GET_CODE (XEXP (base, 1)) == CONST_INT
- && GET_CODE (XEXP (base, 0)) == REG
- && qty_const != 0
- && REGNO_QTY_VALID_P (REGNO (XEXP (base, 0)))
- && (qty_mode[REG_QTY (REGNO (XEXP (base, 0)))]
- == GET_MODE (XEXP (base, 0)))
- && qty_const[REG_QTY (REGNO (XEXP (base, 0)))])
- {
- start = INTVAL (XEXP (base, 1));
- base = qty_const[REG_QTY (REGNO (XEXP (base, 0)))];
- }
- /* This can happen as the result of virtual register instantiation,
- if the initial offset is too large to be a valid address. */
- else if (GET_CODE (base) == PLUS
- && GET_CODE (XEXP (base, 0)) == REG
- && GET_CODE (XEXP (base, 1)) == REG
- && qty_const != 0
- && REGNO_QTY_VALID_P (REGNO (XEXP (base, 0)))
- && (qty_mode[REG_QTY (REGNO (XEXP (base, 0)))]
- == GET_MODE (XEXP (base, 0)))
- && qty_const[REG_QTY (REGNO (XEXP (base, 0)))]
- && REGNO_QTY_VALID_P (REGNO (XEXP (base, 1)))
- && (qty_mode[REG_QTY (REGNO (XEXP (base, 1)))]
- == GET_MODE (XEXP (base, 1)))
- && qty_const[REG_QTY (REGNO (XEXP (base, 1)))])
- {
- rtx tem = qty_const[REG_QTY (REGNO (XEXP (base, 1)))];
- base = qty_const[REG_QTY (REGNO (XEXP (base, 0)))];
-
- /* One of the two values must be a constant. */
- if (GET_CODE (base) != CONST_INT)
- {
- if (GET_CODE (tem) != CONST_INT)
- abort ();
- start = INTVAL (tem);
- }
- else
- {
- start = INTVAL (base);
- base = tem;
- }
- }
-
- /* Handle everything that we can find inside an address that has been
- viewed as constant. */
-
- while (1)
- {
- /* If no part of this switch does a "continue", the code outside
- will exit this loop. */
-
- switch (GET_CODE (base))
- {
- case LO_SUM:
- /* By definition, operand1 of a LO_SUM is the associated constant
- address. Use the associated constant address as the base
- instead. */
- base = XEXP (base, 1);
- continue;
-
- case CONST:
- /* Strip off CONST. */
- base = XEXP (base, 0);
- continue;
-
- case PLUS:
- if (GET_CODE (XEXP (base, 1)) == CONST_INT)
- {
- start += INTVAL (XEXP (base, 1));
- base = XEXP (base, 0);
- continue;
- }
- break;
-
- case AND:
- /* Handle the case of an AND which is the negative of a power of
- two. This is used to represent unaligned memory operations. */
- if (GET_CODE (XEXP (base, 1)) == CONST_INT
- && exact_log2 (- INTVAL (XEXP (base, 1))) > 0)
- {
- set_nonvarying_address_components (XEXP (base, 0), size,
- pbase, pstart, pend);
-
- /* Assume the worst misalignment. START is affected, but not
- END, so compensate but adjusting SIZE. Don't lose any
- constant we already had. */
-
- size = *pend - *pstart - INTVAL (XEXP (base, 1)) - 1;
- start += *pstart + INTVAL (XEXP (base, 1)) + 1;
- end += *pend;
- base = *pbase;
- }
- break;
-
- default:
- break;
- }
-
- break;
- }
-
- if (GET_CODE (base) == CONST_INT)
- {
- start += INTVAL (base);
- base = const0_rtx;
- }
-
- end = start + size;
-
- /* Set the return values. */
- *pbase = base;
- *pstart = start;
- *pend = end;
-}
-
/* Return 1 if X has a value that can vary even between two
executions of the program. 0 means X can be compared reliably
against certain constants or near-constants. */
doesn't vary in any mode. */
if (GET_CODE (x) == REG
- && REGNO_QTY_VALID_P (REGNO (x))
- && GET_MODE (x) == qty_mode[REG_QTY (REGNO (x))]
- && qty_const[REG_QTY (REGNO (x))] != 0)
- return 0;
+ && REGNO_QTY_VALID_P (REGNO (x)))
+ {
+ int x_q = REG_QTY (REGNO (x));
+ struct qty_table_elem *x_ent = &qty_table[x_q];
+
+ if (GET_MODE (x) == x_ent->mode
+ && x_ent->const_rtx != NULL_RTX)
+ return 0;
+ }
if (GET_CODE (x) == PLUS
&& GET_CODE (XEXP (x, 1)) == CONST_INT
&& GET_CODE (XEXP (x, 0)) == REG
- && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))
- && (GET_MODE (XEXP (x, 0))
- == qty_mode[REG_QTY (REGNO (XEXP (x, 0)))])
- && qty_const[REG_QTY (REGNO (XEXP (x, 0)))])
- return 0;
+ && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0))))
+ {
+ int x0_q = REG_QTY (REGNO (XEXP (x, 0)));
+ struct qty_table_elem *x0_ent = &qty_table[x0_q];
+
+ if ((GET_MODE (XEXP (x, 0)) == x0_ent->mode)
+ && x0_ent->const_rtx != NULL_RTX)
+ return 0;
+ }
/* This can happen as the result of virtual register instantiation, if
the initial constant is too large to be a valid address. This gives
&& GET_CODE (XEXP (x, 0)) == REG
&& GET_CODE (XEXP (x, 1)) == REG
&& REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))
- && (GET_MODE (XEXP (x, 0))
- == qty_mode[REG_QTY (REGNO (XEXP (x, 0)))])
- && qty_const[REG_QTY (REGNO (XEXP (x, 0)))]
- && REGNO_QTY_VALID_P (REGNO (XEXP (x, 1)))
- && (GET_MODE (XEXP (x, 1))
- == qty_mode[REG_QTY (REGNO (XEXP (x, 1)))])
- && qty_const[REG_QTY (REGNO (XEXP (x, 1)))])
- return 0;
+ && REGNO_QTY_VALID_P (REGNO (XEXP (x, 1))))
+ {
+ int x0_q = REG_QTY (REGNO (XEXP (x, 0)));
+ int x1_q = REG_QTY (REGNO (XEXP (x, 1)));
+ struct qty_table_elem *x0_ent = &qty_table[x0_q];
+ struct qty_table_elem *x1_ent = &qty_table[x1_q];
+
+ if ((GET_MODE (XEXP (x, 0)) == x0_ent->mode)
+ && x0_ent->const_rtx != NULL_RTX
+ && (GET_MODE (XEXP (x, 1)) == x1_ent->mode)
+ && x1_ent->const_rtx != NULL_RTX)
+ return 0;
+ }
return rtx_varies_p (x);
}
case REG:
{
register int first;
+ register int q;
+ register struct qty_table_elem *ent;
/* Never replace a hard reg, because hard regs can appear
in more than one machine mode, and we must preserve the mode
|| ! REGNO_QTY_VALID_P (REGNO (x)))
return x;
- first = qty_first_reg[REG_QTY (REGNO (x))];
+ q = REG_QTY (REGNO(x));
+ ent = &qty_table[q];
+ first = ent->first_reg;
return (first >= FIRST_PSEUDO_REGISTER ? regno_reg_rtx[first]
: REGNO_REG_CLASS (first) == NO_REGS ? x
- : gen_rtx_REG (qty_mode[REG_QTY (REGNO (x))], first));
+ : gen_rtx_REG (ent->mode, first));
}
default:
&& code == LT && STORE_FLAG_VALUE == -1)
#ifdef FLOAT_STORE_FLAG_VALUE
|| (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
- && FLOAT_STORE_FLAG_VALUE < 0)
+ && (REAL_VALUE_NEGATIVE
+ (FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)))))
#endif
)
x = arg1;
&& code == GE && STORE_FLAG_VALUE == -1)
#ifdef FLOAT_STORE_FLAG_VALUE
|| (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT
- && FLOAT_STORE_FLAG_VALUE < 0)
+ && (REAL_VALUE_NEGATIVE
+ (FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)))))
#endif
)
x = arg1, reverse_code = 1;
if (x == 0)
/* Look up ARG1 in the hash table and see if it has an equivalence
that lets us see what is being compared. */
- p = lookup (arg1, safe_hash (arg1, GET_MODE (arg1)) % NBUCKETS,
+ p = lookup (arg1, safe_hash (arg1, GET_MODE (arg1)) & HASH_MASK,
GET_MODE (arg1));
if (p) p = p->first_same_value;
#ifdef FLOAT_STORE_FLAG_VALUE
|| (code == LT
&& GET_MODE_CLASS (inner_mode) == MODE_FLOAT
- && FLOAT_STORE_FLAG_VALUE < 0)
+ && (REAL_VALUE_NEGATIVE
+ (FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)))))
#endif
)
&& GET_RTX_CLASS (GET_CODE (p->exp)) == '<'))
#ifdef FLOAT_STORE_FLAG_VALUE
|| (code == GE
&& GET_MODE_CLASS (inner_mode) == MODE_FLOAT
- && FLOAT_STORE_FLAG_VALUE < 0)
+ && (REAL_VALUE_NEGATIVE
+ (FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)))))
#endif
)
&& GET_RTX_CLASS (GET_CODE (p->exp)) == '<')
&& GET_MODE (SUBREG_REG (elt->exp)) == mode
&& exp_equiv_p (elt->exp, elt->exp, 1, 0))
return copy_rtx (SUBREG_REG (elt->exp));
- }
+ }
return x;
}
HOST_WIDE_INT offset = 0;
if (GET_CODE (addr) == REG
- && REGNO_QTY_VALID_P (REGNO (addr))
- && GET_MODE (addr) == qty_mode[REG_QTY (REGNO (addr))]
- && qty_const[REG_QTY (REGNO (addr))] != 0)
- addr = qty_const[REG_QTY (REGNO (addr))];
+ && REGNO_QTY_VALID_P (REGNO (addr)))
+ {
+ int addr_q = REG_QTY (REGNO (addr));
+ struct qty_table_elem *addr_ent = &qty_table[addr_q];
+
+ if (GET_MODE (addr) == addr_ent->mode
+ && addr_ent->const_rtx != NULL_RTX)
+ addr = addr_ent->const_rtx;
+ }
/* If address is constant, split it into a base and integer offset. */
if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF)
case REG:
/* This is the same as calling equiv_constant; it is duplicated
here for speed. */
- if (REGNO_QTY_VALID_P (REGNO (arg))
- && qty_const[REG_QTY (REGNO (arg))] != 0
- && GET_CODE (qty_const[REG_QTY (REGNO (arg))]) != REG
- && GET_CODE (qty_const[REG_QTY (REGNO (arg))]) != PLUS)
- const_arg
- = gen_lowpart_if_possible (GET_MODE (arg),
- qty_const[REG_QTY (REGNO (arg))]);
+ if (REGNO_QTY_VALID_P (REGNO (arg)))
+ {
+ int arg_q = REG_QTY (REGNO (arg));
+ struct qty_table_elem *arg_ent = &qty_table[arg_q];
+
+ if (arg_ent->const_rtx != NULL_RTX
+ && GET_CODE (arg_ent->const_rtx) != REG
+ && GET_CODE (arg_ent->const_rtx) != PLUS)
+ const_arg
+ = gen_lowpart_if_possible (GET_MODE (arg),
+ arg_ent->const_rtx);
+ }
break;
case CONST:
#ifdef FLOAT_STORE_FLAG_VALUE
if (GET_MODE_CLASS (mode) == MODE_FLOAT)
{
- true = CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE,
- mode);
+ true = (CONST_DOUBLE_FROM_REAL_VALUE
+ (FLOAT_STORE_FLAG_VALUE (mode), mode));
false = CONST0_RTX (mode);
}
#endif
== REG_QTY (REGNO (folded_arg1))))
|| ((p0 = lookup (folded_arg0,
(safe_hash (folded_arg0, mode_arg0)
- % NBUCKETS), mode_arg0))
+ & HASH_MASK), mode_arg0))
&& (p1 = lookup (folded_arg1,
(safe_hash (folded_arg1, mode_arg0)
- % NBUCKETS), mode_arg0))
+ & HASH_MASK), mode_arg0))
&& p0->first_same_value == p1->first_same_value)))
return ((code == EQ || code == LE || code == GE
|| code == LEU || code == GEU)
{
int qty = REG_QTY (REGNO (folded_arg0));
- if (REGNO_QTY_VALID_P (REGNO (folded_arg0))
- && (comparison_dominates_p (qty_comparison_code[qty], code)
- || (comparison_dominates_p (qty_comparison_code[qty],
- reverse_condition (code))
- && ! FLOAT_MODE_P (mode_arg0)))
- && (rtx_equal_p (qty_comparison_const[qty], folded_arg1)
- || (const_arg1
- && rtx_equal_p (qty_comparison_const[qty],
- const_arg1))
- || (GET_CODE (folded_arg1) == REG
- && (REG_QTY (REGNO (folded_arg1))
- == qty_comparison_qty[qty]))))
- return (comparison_dominates_p (qty_comparison_code[qty],
- code)
- ? true : false);
+ if (REGNO_QTY_VALID_P (REGNO (folded_arg0)))
+ {
+ struct qty_table_elem *ent = &qty_table[qty];
+
+ if ((comparison_dominates_p (ent->comparison_code, code)
+ || (! FLOAT_MODE_P (mode_arg0)
+ && comparison_dominates_p (ent->comparison_code,
+ reverse_condition (code))))
+ && (rtx_equal_p (ent->comparison_const, folded_arg1)
+ || (const_arg1
+ && rtx_equal_p (ent->comparison_const,
+ const_arg1))
+ || (GET_CODE (folded_arg1) == REG
+ && (REG_QTY (REGNO (folded_arg1)) == ent->comparison_qty))))
+ return (comparison_dominates_p (ent->comparison_code, code)
+ ? true : false);
+ }
}
}
}
#ifdef FLOAT_STORE_FLAG_VALUE
if (GET_MODE_CLASS (mode) == MODE_FLOAT)
{
- true = CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE,
- mode);
+ true = (CONST_DOUBLE_FROM_REAL_VALUE
+ (FLOAT_STORE_FLAG_VALUE (mode), mode));
false = CONST0_RTX (mode);
}
#endif
const_arg1 ? const_arg1 : folded_arg1);
#ifdef FLOAT_STORE_FLAG_VALUE
if (new != 0 && GET_MODE_CLASS (mode) == MODE_FLOAT)
- new = ((new == const0_rtx) ? CONST0_RTX (mode)
- : CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE, mode));
+ {
+ if (new == const0_rtx)
+ new = CONST0_RTX (mode);
+ else
+ new = (CONST_DOUBLE_FROM_REAL_VALUE
+ (FLOAT_STORE_FLAG_VALUE (mode), mode));
+ }
#endif
break;
{
rtx new_const = GEN_INT (- INTVAL (const_arg1));
struct table_elt *p
- = lookup (new_const, safe_hash (new_const, mode) % NBUCKETS,
+ = lookup (new_const, safe_hash (new_const, mode) & HASH_MASK,
mode);
if (p)
rtx x;
{
if (GET_CODE (x) == REG
- && REGNO_QTY_VALID_P (REGNO (x))
- && qty_const[REG_QTY (REGNO (x))])
- x = gen_lowpart_if_possible (GET_MODE (x), qty_const[REG_QTY (REGNO (x))]);
+ && REGNO_QTY_VALID_P (REGNO (x)))
+ {
+ int x_q = REG_QTY (REGNO (x));
+ struct qty_table_elem *x_ent = &qty_table[x_q];
+
+ if (x_ent->const_rtx)
+ x = gen_lowpart_if_possible (GET_MODE (x), x_ent->const_rtx);
+ }
if (x == 0 || CONSTANT_P (x))
return x;
if (CONSTANT_P (x))
return x;
- elt = lookup (x, safe_hash (x, GET_MODE (x)) % NBUCKETS, GET_MODE (x));
+ elt = lookup (x, safe_hash (x, GET_MODE (x)) & HASH_MASK, GET_MODE (x));
if (elt == 0)
return 0;
{
reversed_nonequality = (code != EQ && code != NE);
code = reverse_condition (code);
+
+ /* Don't remember if we can't find the inverse. */
+ if (code == UNKNOWN)
+ return;
}
/* The mode is the mode of the non-constant. */
if (code != EQ || FLOAT_MODE_P (GET_MODE (op0)))
{
+ struct qty_table_elem *ent;
+ int qty;
+
/* If we reversed a floating-point comparison, if OP0 is not a
register, or if OP1 is neither a register or constant, we can't
do anything. */
op0_elt->in_memory = op0_in_memory;
}
- qty_comparison_code[REG_QTY (REGNO (op0))] = code;
+ qty = REG_QTY (REGNO (op0));
+ ent = &qty_table[qty];
+
+ ent->comparison_code = code;
if (GET_CODE (op1) == REG)
{
/* Look it up again--in case op0 and op1 are the same. */
op1_elt->in_memory = op1_in_memory;
}
- qty_comparison_qty[REG_QTY (REGNO (op0))] = REG_QTY (REGNO (op1));
- qty_comparison_const[REG_QTY (REGNO (op0))] = 0;
+ ent->comparison_const = NULL_RTX;
+ ent->comparison_qty = REG_QTY (REGNO (op1));
}
else
{
- qty_comparison_qty[REG_QTY (REGNO (op0))] = -1;
- qty_comparison_const[REG_QTY (REGNO (op0))] = op1;
+ ent->comparison_const = op1;
+ ent->comparison_qty = -1;
}
return;
enum machine_mode mode;
/* A constant equivalent for SET_SRC, if any. */
rtx src_const;
+ /* Original SET_SRC value used for libcall notes. */
+ rtx orig_src;
/* Hash value of constant equivalent for SET_SRC. */
unsigned src_const_hash;
/* Table entry for constant equivalent for SET_SRC, if any. */
int src_eqv_in_memory = 0;
unsigned src_eqv_hash = 0;
- struct set *sets = NULL_PTR;
+ struct set *sets = (struct set *) NULL_PTR;
this_insn = insn;
rtx new = canon_reg (src, insn);
int insn_code;
+ sets[i].orig_src = src;
if ((GET_CODE (new) == REG && GET_CODE (src) == REG
&& ((REGNO (new) < FIRST_PSEUDO_REGISTER)
!= (REGNO (src) < FIRST_PSEUDO_REGISTER)))
the current contents will be tested and will always be valid. */
while (1)
{
- rtx trial, old_src;
+ rtx trial;
/* Skip invalid entries. */
while (elt && GET_CODE (elt->exp) != REG
insert the substitution here and we will delete and re-emit
the insn later. */
- /* Keep track of the original SET_SRC so that we can fix notes
- on libcall instructions. */
- old_src = SET_SRC (sets[i].rtl);
-
if (n_sets == 1 && dest == pc_rtx
&& (trial == pc_rtx
|| (GET_CODE (trial) == LABEL_REF
&& ! condjump_p (insn))))
{
- /* If TRIAL is a label in front of a jump table, we are
- really falling through the switch (this is how casesi
- insns work), so we must branch around the table. */
- if (GET_CODE (trial) == CODE_LABEL
- && NEXT_INSN (trial) != 0
- && GET_CODE (NEXT_INSN (trial)) == JUMP_INSN
- && (GET_CODE (PATTERN (NEXT_INSN (trial))) == ADDR_DIFF_VEC
- || GET_CODE (PATTERN (NEXT_INSN (trial))) == ADDR_VEC))
-
- trial = gen_rtx_LABEL_REF (Pmode, get_label_after (trial));
-
- SET_SRC (sets[i].rtl) = trial;
- cse_jumps_altered = 1;
+ if (trial == pc_rtx)
+ {
+ SET_SRC (sets[i].rtl) = trial;
+ cse_jumps_altered = 1;
+ break;
+ }
+
+ PATTERN (insn) = gen_jump (XEXP (trial, 0));
+ INSN_CODE (insn) = -1;
+ cse_jumps_altered = 1;
break;
}
need to make the same substitution in any notes attached
to the RETVAL insn. */
if (libcall_insn
- && (GET_CODE (old_src) == REG
- || GET_CODE (old_src) == SUBREG
- || GET_CODE (old_src) == MEM))
- replace_rtx (REG_NOTES (libcall_insn), old_src,
+ && (GET_CODE (sets[i].orig_src) == REG
+ || GET_CODE (sets[i].orig_src) == SUBREG
+ || GET_CODE (sets[i].orig_src) == MEM))
+ replace_rtx (REG_NOTES (libcall_insn), sets[i].orig_src,
canon_reg (SET_SRC (sets[i].rtl), insn));
/* The result of apply_change_group can be ignored; see
both registers live over a portion of the basic block. This way,
their lifetimes will likely abut instead of overlapping. */
if (GET_CODE (dest) == REG
- && REGNO_QTY_VALID_P (REGNO (dest))
- && qty_mode[REG_QTY (REGNO (dest))] == GET_MODE (dest)
- && qty_first_reg[REG_QTY (REGNO (dest))] != REGNO (dest)
- && GET_CODE (src) == REG && REGNO (src) == REGNO (dest)
- /* Don't do this if the original insn had a hard reg as
- SET_SRC or SET_DEST. */
- && (GET_CODE (sets[i].src) != REG
- || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER)
- && (GET_CODE (dest) != REG || REGNO (dest) >= FIRST_PSEUDO_REGISTER))
- /* We can't call canon_reg here because it won't do anything if
- SRC is a hard register. */
+ && REGNO_QTY_VALID_P (REGNO (dest)))
{
- int first = qty_first_reg[REG_QTY (REGNO (src))];
- rtx new_src
- = (first >= FIRST_PSEUDO_REGISTER
- ? regno_reg_rtx[first] : gen_rtx_REG (GET_MODE (src), first));
-
- /* We must use validate-change even for this, because this
- might be a special no-op instruction, suitable only to
- tag notes onto. */
- if (validate_change (insn, &SET_SRC (sets[i].rtl), new_src, 0))
+ int dest_q = REG_QTY (REGNO (dest));
+ struct qty_table_elem *dest_ent = &qty_table[dest_q];
+
+ if (dest_ent->mode == GET_MODE (dest)
+ && dest_ent->first_reg != REGNO (dest)
+ && GET_CODE (src) == REG && REGNO (src) == REGNO (dest)
+ /* Don't do this if the original insn had a hard reg as
+ SET_SRC or SET_DEST. */
+ && (GET_CODE (sets[i].src) != REG
+ || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER)
+ && (GET_CODE (dest) != REG || REGNO (dest) >= FIRST_PSEUDO_REGISTER))
+ /* We can't call canon_reg here because it won't do anything if
+ SRC is a hard register. */
{
- src = new_src;
- /* If we had a constant that is cheaper than what we are now
- setting SRC to, use that constant. We ignored it when we
- thought we could make this into a no-op. */
- if (src_const && COST (src_const) < COST (src)
- && validate_change (insn, &SET_SRC (sets[i].rtl), src_const,
- 0))
- src = src_const;
+ int src_q = REG_QTY (REGNO (src));
+ struct qty_table_elem *src_ent = &qty_table[src_q];
+ int first = src_ent->first_reg;
+ rtx new_src
+ = (first >= FIRST_PSEUDO_REGISTER
+ ? regno_reg_rtx[first] : gen_rtx_REG (GET_MODE (src), first));
+
+ /* We must use validate-change even for this, because this
+ might be a special no-op instruction, suitable only to
+ tag notes onto. */
+ if (validate_change (insn, &SET_SRC (sets[i].rtl), new_src, 0))
+ {
+ src = new_src;
+ /* If we had a constant that is cheaper than what we are now
+ setting SRC to, use that constant. We ignored it when we
+ thought we could make this into a no-op. */
+ if (src_const && COST (src_const) < COST (src)
+ && validate_change (insn, &SET_SRC (sets[i].rtl), src_const,
+ 0))
+ src = src_const;
+ }
}
}
/* If we made a change, recompute SRC values. */
if (src != sets[i].src)
{
+ cse_altered = 1;
do_not_record = 0;
hash_arg_in_memory = 0;
sets[i].src = src;
Rather than track each register individually, we just see if
the last set for this quantity was for this register. */
- if (REGNO_QTY_VALID_P (REGNO (dest))
- && qty_const[REG_QTY (REGNO (dest))] == const0_rtx)
+ if (REGNO_QTY_VALID_P (REGNO (dest)))
{
- /* See if we previously had a REG_WAS_0 note. */
- rtx note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
- rtx const_insn = qty_const_insn[REG_QTY (REGNO (dest))];
+ int dest_q = REG_QTY (REGNO (dest));
+ struct qty_table_elem *dest_ent = &qty_table[dest_q];
- if ((tem = single_set (const_insn)) != 0
- && rtx_equal_p (SET_DEST (tem), dest))
+ if (dest_ent->const_rtx == const0_rtx)
{
- if (note)
- XEXP (note, 0) = const_insn;
- else
- REG_NOTES (insn)
- = gen_rtx_INSN_LIST (REG_WAS_0, const_insn,
- REG_NOTES (insn));
+ /* See if we previously had a REG_WAS_0 note. */
+ rtx note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
+ rtx const_insn = dest_ent->const_insn;
+
+ if ((tem = single_set (const_insn)) != 0
+ && rtx_equal_p (SET_DEST (tem), dest))
+ {
+ if (note)
+ XEXP (note, 0) = const_insn;
+ else
+ REG_NOTES (insn)
+ = gen_rtx_INSN_LIST (REG_WAS_0, const_insn,
+ REG_NOTES (insn));
+ }
}
}
}
/* We used to rely on all references to a register becoming
inaccessible when a register changes to a new quantity,
since that changes the hash code. However, that is not
- safe, since after NBUCKETS new quantities we get a
+ safe, since after HASH_SIZE new quantities we get a
hash 'collision' of a register with its own invalid
entries. And since SUBREGs have been changed not to
change their hash code with the hash code of the register,
This code is similar to the REG case in mention_regs,
but it knows that reg_tick has been incremented, and
it leaves reg_in_table as -1 . */
- register int regno = REGNO (x);
- register int endregno
+ unsigned int regno = REGNO (x);
+ unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
: HARD_REGNO_NREGS (regno, GET_MODE (x)));
- int i;
+ unsigned int i;
for (i = regno; i < endregno; i++)
{
&& NEXT_INSN (PREV_INSN (insn)) == insn
&& GET_CODE (SET_SRC (sets[0].rtl)) == REG
&& REGNO (SET_SRC (sets[0].rtl)) >= FIRST_PSEUDO_REGISTER
- && REGNO_QTY_VALID_P (REGNO (SET_SRC (sets[0].rtl)))
- && (qty_first_reg[REG_QTY (REGNO (SET_SRC (sets[0].rtl)))]
- == REGNO (SET_DEST (sets[0].rtl)))
- && ! find_reg_note (insn, REG_RETVAL, NULL_RTX))
+ && REGNO_QTY_VALID_P (REGNO (SET_SRC (sets[0].rtl))))
{
- rtx prev = PREV_INSN (insn);
- while (prev && GET_CODE (prev) == NOTE)
- prev = PREV_INSN (prev);
+ int src_q = REG_QTY (REGNO (SET_SRC (sets[0].rtl)));
+ struct qty_table_elem *src_ent = &qty_table[src_q];
- if (prev && GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SET
- && SET_DEST (PATTERN (prev)) == SET_SRC (sets[0].rtl))
+ if ((src_ent->first_reg == REGNO (SET_DEST (sets[0].rtl)))
+ && ! find_reg_note (insn, REG_RETVAL, NULL_RTX))
{
- rtx dest = SET_DEST (sets[0].rtl);
- rtx note = find_reg_note (prev, REG_EQUIV, NULL_RTX);
+ rtx prev = PREV_INSN (insn);
+ while (prev && GET_CODE (prev) == NOTE)
+ prev = PREV_INSN (prev);
- validate_change (prev, & SET_DEST (PATTERN (prev)), dest, 1);
- validate_change (insn, & SET_DEST (sets[0].rtl),
- SET_SRC (sets[0].rtl), 1);
- validate_change (insn, & SET_SRC (sets[0].rtl), dest, 1);
- apply_change_group ();
+ if (prev && GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SET
+ && SET_DEST (PATTERN (prev)) == SET_SRC (sets[0].rtl))
+ {
+ rtx dest = SET_DEST (sets[0].rtl);
+ rtx note = find_reg_note (prev, REG_EQUIV, NULL_RTX);
- /* If REG1 was equivalent to a constant, REG0 is not. */
- if (note)
- PUT_REG_NOTE_KIND (note, REG_EQUAL);
+ validate_change (prev, & SET_DEST (PATTERN (prev)), dest, 1);
+ validate_change (insn, & SET_DEST (sets[0].rtl),
+ SET_SRC (sets[0].rtl), 1);
+ validate_change (insn, & SET_SRC (sets[0].rtl), dest, 1);
+ apply_change_group ();
- /* If there was a REG_WAS_0 note on PREV, remove it. Move
- any REG_WAS_0 note on INSN to PREV. */
- note = find_reg_note (prev, REG_WAS_0, NULL_RTX);
- if (note)
- remove_note (prev, note);
+ /* If REG1 was equivalent to a constant, REG0 is not. */
+ if (note)
+ PUT_REG_NOTE_KIND (note, REG_EQUAL);
- note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
- if (note)
- {
- remove_note (insn, note);
- XEXP (note, 1) = REG_NOTES (prev);
- REG_NOTES (prev) = note;
- }
+ /* If there was a REG_WAS_0 note on PREV, remove it. Move
+ any REG_WAS_0 note on INSN to PREV. */
+ note = find_reg_note (prev, REG_WAS_0, NULL_RTX);
+ if (note)
+ remove_note (prev, note);
- /* If INSN has a REG_EQUAL note, and this note mentions REG0,
- then we must delete it, because the value in REG0 has changed. */
- note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
- if (note && reg_mentioned_p (dest, XEXP (note, 0)))
- remove_note (insn, note);
+ note = find_reg_note (insn, REG_WAS_0, NULL_RTX);
+ if (note)
+ {
+ remove_note (insn, note);
+ XEXP (note, 1) = REG_NOTES (prev);
+ REG_NOTES (prev) = note;
+ }
+
+ /* If INSN has a REG_EQUAL note, and this note mentions REG0,
+ then we must delete it, because the value in REG0 has changed. */
+ note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
+ if (note && reg_mentioned_p (dest, XEXP (note, 0)))
+ remove_note (insn, note);
+ }
}
}
register int i;
register struct table_elt *p, *next;
- for (i = 0; i < NBUCKETS; i++)
+ for (i = 0; i < HASH_SIZE; i++)
for (p = table[i]; p; p = next)
{
next = p->next_same_hash;
}
}
-#ifdef AUTO_INC_DEC
-
/* If ADDR is an address that implicitly affects the stack pointer, return
1 and update the register tables to show the effect. Else, return 0. */
return 0;
}
-#endif
/* Perform invalidation on the basis of everything about an insn
except for invalidating the actual places that are SET in it.
i = REG_QTY (REGNO (x));
/* Return a constant or a constant register. */
- if (REGNO_QTY_VALID_P (REGNO (x))
- && qty_const[i] != 0
- && (CONSTANT_P (qty_const[i])
- || GET_CODE (qty_const[i]) == REG))
+ if (REGNO_QTY_VALID_P (REGNO (x)))
{
- rtx new = gen_lowpart_if_possible (GET_MODE (x), qty_const[i]);
- if (new)
- return new;
+ struct qty_table_elem *ent = &qty_table[i];
+
+ if (ent->const_rtx != NULL_RTX
+ && (CONSTANT_P (ent->const_rtx)
+ || GET_CODE (ent->const_rtx) == REG))
+ {
+ rtx new = gen_lowpart_if_possible (GET_MODE (x), ent->const_rtx);
+ if (new)
+ return new;
+ }
}
/* Otherwise, canonicalize this register. */
enum rtx_code code = GET_CODE (dest);
if (code == MEM
-#ifdef AUTO_INC_DEC
&& ! addr_affects_sp_p (dest) /* If this is not a stack push ... */
-#endif
/* There are times when an address can appear varying and be a PLUS
during this scan when it would be a fixed address were we to know
the proper equivalences. So invalidate all memory if there is
}
}
-#ifdef AUTO_INC_DEC
/* Deal with the destination of X affecting the stack pointer. */
addr_affects_sp_p (SET_DEST (x));
-#endif
/* See comment on similar code in cse_insn for explanation of these
tests. */
max_insn_uid = get_max_uid ();
- reg_next_eqv = (int *) xmalloc (nregs * sizeof (int));
- reg_prev_eqv = (int *) xmalloc (nregs * sizeof (int));
+ reg_eqv_table = (struct reg_eqv_elem *)
+ xmalloc (nregs * sizeof (struct reg_eqv_elem));
#ifdef LOAD_EXTEND_OP
insn = f;
while (insn)
{
+ cse_altered = 0;
cse_end_of_basic_block (insn, &val, flag_cse_follow_jumps, after_loop,
flag_cse_skip_blocks);
cse_jumps_altered |= old_cse_jumps_altered;
}
- if (ggc_p)
+ if (ggc_p && cse_altered)
ggc_collect ();
#ifdef USE_C_ALLOCA
if (ggc_p)
ggc_pop_context ();
- /* Tell refers_to_mem_p that qty_const info is not available. */
- qty_const = 0;
-
if (max_elements_made < n_elements_made)
max_elements_made = n_elements_made;
/* Clean up. */
end_alias_analysis ();
free (uid_cuid);
- free (reg_next_eqv);
- free (reg_prev_eqv);
+ free (reg_eqv_table);
return cse_jumps_altered || recorded_label_ref;
}
rtx libcall_insn = NULL_RTX;
int num_insns = 0;
- /* Each of these arrays is undefined before max_reg, so only allocate
- the space actually needed and adjust the start below. */
-
- qty_first_reg = (int *) xmalloc ((max_qty - max_reg) * sizeof (int));
- qty_last_reg = (int *) xmalloc ((max_qty - max_reg) * sizeof (int));
- qty_mode = (enum machine_mode *) xmalloc ((max_qty - max_reg)
- * sizeof (enum machine_mode));
- qty_const = (rtx *) xmalloc ((max_qty - max_reg) * sizeof (rtx));
- qty_const_insn = (rtx *) xmalloc ((max_qty - max_reg) * sizeof (rtx));
- qty_comparison_code
- = (enum rtx_code *) xmalloc ((max_qty - max_reg) * sizeof (enum rtx_code));
- qty_comparison_qty = (int *) xmalloc ((max_qty - max_reg) * sizeof (int));
- qty_comparison_const = (rtx *) xmalloc ((max_qty - max_reg) * sizeof (rtx));
-
- qty_first_reg -= max_reg;
- qty_last_reg -= max_reg;
- qty_mode -= max_reg;
- qty_const -= max_reg;
- qty_const_insn -= max_reg;
- qty_comparison_code -= max_reg;
- qty_comparison_qty -= max_reg;
- qty_comparison_const -= max_reg;
+ /* This array is undefined before max_reg, so only allocate
+ the space actually needed and adjust the start. */
+
+ qty_table
+ = (struct qty_table_elem *) xmalloc ((max_qty - max_reg)
+ * sizeof (struct qty_table_elem));
+ qty_table -= max_reg;
new_basic_block ();
/* If we have processed 1,000 insns, flush the hash table to
avoid extreme quadratic behavior. We must not include NOTEs
- in the count since there may be more or them when generating
+ in the count since there may be more of them when generating
debugging information. If we clear the table at different
times, code generated with -g -O might be different than code
generated with -O but not -g.
if (simplejump_p (insn))
{
if (to == 0)
- return 0;
+ {
+ free (qty_table + max_reg);
+ return 0;
+ }
if (JUMP_LABEL (insn) == to)
to_usage = 1;
/* If TO was the last insn in the function, we are done. */
if (insn == 0)
- return 0;
+ {
+ free (qty_table + max_reg);
+ return 0;
+ }
/* If TO was preceded by a BARRIER we are done with this block
because it has no continuation. */
prev = prev_nonnote_insn (to);
if (prev && GET_CODE (prev) == BARRIER)
- return insn;
+ {
+ free (qty_table + max_reg);
+ return insn;
+ }
/* Find the end of the following block. Note that we won't be
following branches in this case. */
&& LABEL_NUSES (JUMP_LABEL (PREV_INSN (to))) == 1)
cse_around_loop (JUMP_LABEL (PREV_INSN (to)));
- free (qty_first_reg + max_reg);
- free (qty_last_reg + max_reg);
- free (qty_mode + max_reg);
- free (qty_const + max_reg);
- free (qty_const_insn + max_reg);
- free (qty_comparison_code + max_reg);
- free (qty_comparison_qty + max_reg);
- free (qty_comparison_const + max_reg);
+ free (qty_table + max_reg);
return to ? NEXT_INSN (to) : 0;
}
live_insn = ! dead_libcall;
else if (GET_CODE (PATTERN (insn)) == SET)
{
- if (GET_CODE (SET_DEST (PATTERN (insn))) == REG
- && SET_DEST (PATTERN (insn)) == SET_SRC (PATTERN (insn)))
+ if ((GET_CODE (SET_DEST (PATTERN (insn))) == REG
+ || GET_CODE (SET_DEST (PATTERN (insn))) == SUBREG)
+ && rtx_equal_p (SET_DEST (PATTERN (insn)),
+ SET_SRC (PATTERN (insn))))
+ ;
+ else if (GET_CODE (SET_DEST (PATTERN (insn))) == STRICT_LOW_PART
+ && rtx_equal_p (XEXP (SET_DEST (PATTERN (insn)), 0),
+ SET_SRC (PATTERN (insn))))
;
#ifdef HAVE_cc0
if (GET_CODE (elt) == SET)
{
- if (GET_CODE (SET_DEST (elt)) == REG
- && SET_DEST (elt) == SET_SRC (elt))
+ if ((GET_CODE (SET_DEST (elt)) == REG
+ || GET_CODE (SET_DEST (elt)) == SUBREG)
+ && rtx_equal_p (SET_DEST (elt), SET_SRC (elt)))
;
#ifdef HAVE_cc0
OSDN Git Service
