/* Common subexpression elimination for GNU compiler.
- Copyright (C) 1987, 88, 89, 92-7, 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 89, 92-99, 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;
+ 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. */
+
+/* Per-register equivalence chain. */
+struct reg_eqv_elem
+{
+ int next, prev;
+};
-static int *reg_next_eqv;
-static int *reg_prev_eqv;
+/* 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 */
+ 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. */
/* 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))
? -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 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));
-static int addr_affects_sp_p PROTO((rtx));
-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 ((int, enum machine_mode));
+static void make_regs_eqv PARAMS ((int, int));
+static void delete_reg_equiv PARAMS ((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 ((int));
+static void remove_invalid_subreg_refs PARAMS ((int, 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 ((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;
get_cse_reg_info (regno)
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;
-}
-
-static unsigned int
-hash_cse_reg_info (el_ptr)
- hash_table_entry_t el_ptr;
-{
- return ((const struct cse_reg_info *) el_ptr)->regno;
-}
+ cached_cse_reg_info = p;
-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)
+make_new_qty (reg, mode)
register int reg;
+ register 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.
{
register int lastr, firstr;
register int q = REG_QTY (old);
+ register 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;
}
}
delete_reg_equiv (reg)
register int reg;
{
+ register struct qty_table_elem *ent;
register int q = REG_QTY (reg);
register int p, n;
if (q == 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;
}
if (GET_CODE (x) == REG)
{
register int regno = REGNO (x);
+ register 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 (ent->mode != GET_MODE (x))
+ return 0;
+ }
- if (modified || ! REGNO_QTY_VALID_P (regno))
+ 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;
}
\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;
}
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,
rtx x;
enum rtx_code code;
{
- register struct table_elt *p = lookup (x, safe_hash (x, VOIDmode) % NBUCKETS,
+ 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
{
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)
/* 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->cost = COST (x);
elt->next_same_value = 0;
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))]
- = gen_lowpart_if_possible (GET_MODE (x), p->exp);
- qty_const_insn[REG_QTY (REGNO (x))] = this_insn;
+ 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);
+ 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);
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
}
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;
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;
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;
register struct table_elt *p, *next;
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;
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));
}
/* 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;
}
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
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;
+ }
+
+ /* We must actually validate the change. Consider a target
+ where unconditional jumps are more complex than
+ (set (pc) (label_ref)) such as the fr30. */
+ if (validate_change (insn, &SET_SRC (sets[i].rtl), trial, 0))
+ 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;
+ }
}
}
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,
&& 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;
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. */
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
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 (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;
}
OSDN Git Service
