Copyright (C) 2000 Free Software Foundation, Inc.
Contributed by CodeSourcery, LLC
- This file is part of GNU CC.
+This file is part of GNU CC.
- GNU CC is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
- GNU CC is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with GNU CC; see the file COPYING. If not, write to
- the Free Software Foundation, 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
/* References:
#include "config.h"
#include "system.h"
-
#include "obstack.h"
#include "hashtab.h"
#include "rtl.h"
/* The initial capacity (number of conflict arcs) for newly-created
conflict graphs. */
-#define INITIAL_ARC_CAPACITY (64)
+#define INITIAL_ARC_CAPACITY 64
/* Computes the hash value of the conflict graph arc connecting regs
- R1__ and R2__. R1__ is assumed to be smaller or equal to R2__. */
-#define CONFLICT_HASH_FN(r1__, r2__) ((r2__) * ((r2__) - 1) / 2 + (r1__))
-
-static unsigned arc_hash
- PARAMS ((const void *arcp));
-static int arc_eq
- PARAMS ((const void *arcp1, const void *arcp2));
-static int print_conflict
- PARAMS ((int reg1, int reg2, void *contextp));
-static void mark_reg
- PARAMS ((rtx reg, rtx setter, void *data));
-
-
+ R1 and R2. R1 is assumed to be smaller or equal to R2. */
+#define CONFLICT_HASH_FN(R1, R2) ((R2) * ((R2) - 1) / 2 + (R1))
+
+static unsigned arc_hash PARAMS ((const void *));
+static int arc_eq PARAMS ((const void *, const void *));
+static int print_conflict PARAMS ((int, int, void *));
+static void mark_reg PARAMS ((rtx, rtx, void *));
+\f
/* Callback function to compute the hash value of an arc. Uses
current_graph to locate the graph to which the arc belongs. */
const void *arcp;
{
conflict_graph_arc arc = (conflict_graph_arc) arcp;
+
return CONFLICT_HASH_FN (arc->smaller, arc->larger);
}
{
conflict_graph_arc arc1 = (conflict_graph_arc) arcp1;
conflict_graph_arc arc2 = (conflict_graph_arc) arcp2;
+
return arc1->smaller == arc2->smaller && arc1->larger == arc2->larger;
}
conflict_graph_new (num_regs)
int num_regs;
{
- conflict_graph graph =
- (conflict_graph) xmalloc (sizeof (struct conflict_graph_def));
+ conflict_graph graph
+ = (conflict_graph) xmalloc (sizeof (struct conflict_graph_def));
graph->num_regs = num_regs;
/* Set up the hash table. No delete action is specified; memory
management of arcs is through the obstack. */
- graph->arc_hash_table =
- htab_create (INITIAL_ARC_CAPACITY, &arc_hash, &arc_eq, NULL);
+ graph->arc_hash_table
+ = htab_create (INITIAL_ARC_CAPACITY, &arc_hash, &arc_eq, NULL);
/* Create an obstack for allocating arcs. */
- obstack_init (&(graph->arc_obstack));
+ obstack_init (&graph->arc_obstack);
/* Create and zero the lookup table by register number. */
- graph->neighbor_heads = (conflict_graph_arc *)
- xmalloc (num_regs * sizeof (conflict_graph_arc));
- memset (graph->neighbor_heads, 0,
- num_regs * sizeof (conflict_graph_arc));
+ graph->neighbor_heads
+ = (conflict_graph_arc *) xmalloc (num_regs * sizeof (conflict_graph_arc));
+ memset (graph->neighbor_heads, 0, num_regs * sizeof (conflict_graph_arc));
return graph;
}
conflict_graph_delete (graph)
conflict_graph graph;
{
- obstack_free (&(graph->arc_obstack), NULL);
+ obstack_free (&graph->arc_obstack, NULL);
htab_delete (graph->arc_hash_table);
free (graph->neighbor_heads);
free (graph);
return 0;
/* Allocate an arc. */
- arc = (conflict_graph_arc)
- obstack_alloc (&(graph->arc_obstack),
- sizeof (struct conflict_graph_arc_def));
-
+ arc
+ = (conflict_graph_arc)
+ obstack_alloc (&graph->arc_obstack,
+ sizeof (struct conflict_graph_arc_def));
+
/* Record the reg numbers. */
arc->smaller = smaller;
arc->larger = larger;
while (arc != NULL)
{
int other = arc->smaller;
+
if (other == src)
other = arc->larger;
{
int reg;
struct print_context context;
- context.fp = fp;
+ context.fp = fp;
fprintf (fp, "Conflicts:\n");
+
/* Loop over registers supported in this graph. */
for (reg = 0; reg < graph->num_regs; ++reg)
{
context.reg = reg;
context.started = 0;
+
/* Scan the conflicts for reg, printing as we go. A label for
this line will be printed the first time a conflict is
printed for the reg; we won't start a new line if this reg
has no conflicts. */
conflict_graph_enum (graph, reg, &print_conflict, &context);
+
/* If this reg does have conflicts, end the line. */
if (context.started)
fputc ('\n', fp);
/* Walk the instruction stream backwards. */
head = bb->head;
insn = bb->end;
- for (insn = bb->end;
- insn != head;
- insn = PREV_INSN (insn))
+ for (insn = bb->end; insn != head; insn = PREV_INSN (insn))
{
int born_reg;
int live_reg;
/* For every reg born here, add a conflict with every other
reg live coming into this insn. */
- EXECUTE_IF_SET_IN_REG_SET (born,
- FIRST_PSEUDO_REGISTER,
- born_reg, {
- EXECUTE_IF_SET_IN_REG_SET (live,
- FIRST_PSEUDO_REGISTER,
- live_reg, {
- /* Build the conflict graph in terms of canonical
- regnos. */
- int b = partition_find (p, born_reg);
- int l = partition_find (p, live_reg);
- if (b != l)
- conflict_graph_add (graph, b, l);
- });
- });
+ EXECUTE_IF_SET_IN_REG_SET
+ (born, FIRST_PSEUDO_REGISTER, born_reg,
+ {
+ EXECUTE_IF_SET_IN_REG_SET
+ (live, FIRST_PSEUDO_REGISTER, live_reg,
+ {
+ /* Build the conflict graph in terms of canonical
+ regnos. */
+ int b = partition_find (p, born_reg);
+ int l = partition_find (p, live_reg);
+
+ if (b != l)
+ conflict_graph_add (graph, b, l);
+ });
+ });
/* Morgan's algorithm checks the operands of the insn
and adds them to the set of live regs. Instead, we
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
if (REG_NOTE_KIND (link) == REG_DEAD)
{
- int regno = REGNO (XEXP (link, 0));
+ unsigned int regno = REGNO (XEXP (link, 0));
+
if (REGNO_REG_SET_P (regs, regno))
SET_REGNO_REG_SET (live, regno);
}
-/* Common subexpression elimination for GNU compiler.
+/* RTL simplification functions for GNU compiler.
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000 Free Software Foundation, Inc.
#include "config.h"
-/* stdio.h must precede rtl.h for FFS. */
#include "system.h"
#include <setjmp.h>
|| GET_CODE (X) == ADDRESSOF)
-static rtx simplify_plus_minus PARAMS ((enum rtx_code, enum machine_mode,
- rtx, rtx));
-static void check_fold_consts PARAMS ((PTR));
+static rtx simplify_plus_minus PARAMS ((enum rtx_code,
+ enum machine_mode, rtx, rtx));
+static void check_fold_consts PARAMS ((PTR));
+static int entry_and_rtx_equal_p PARAMS ((const void *, const void *));
+static unsigned int get_value_hash PARAMS ((const void *));
+static struct elt_list *new_elt_list PARAMS ((struct elt_list *,
+ cselib_val *));
+static struct elt_loc_list *new_elt_loc_list PARAMS ((struct elt_loc_list *,
+ rtx));
+static void unchain_one_value PARAMS ((cselib_val *));
+static void unchain_one_elt_list PARAMS ((struct elt_list **));
+static void unchain_one_elt_loc_list PARAMS ((struct elt_loc_list **));
+static void clear_table PARAMS ((void));
+static int check_value_useless PARAMS ((cselib_val *));
+static int discard_useless_locs PARAMS ((void **, void *));
+static int discard_useless_values PARAMS ((void **, void *));
+static void remove_useless_values PARAMS ((void));
+static unsigned int hash_rtx PARAMS ((rtx, enum machine_mode, int));
+static cselib_val *new_cselib_val PARAMS ((unsigned int,
+ enum machine_mode));
+static void add_mem_for_addr PARAMS ((cselib_val *, cselib_val *,
+ rtx));
+static cselib_val *cselib_lookup_mem PARAMS ((rtx, int));
+static rtx cselib_subst_to_values PARAMS ((rtx));
+static void cselib_invalidate_regno PARAMS ((unsigned int,
+ enum machine_mode));
+static int cselib_mem_conflict_p PARAMS ((rtx, rtx));
+static int cselib_invalidate_mem_1 PARAMS ((void **, void *));
+static void cselib_invalidate_mem PARAMS ((rtx));
+static void cselib_invalidate_rtx PARAMS ((rtx, rtx, void *));
+static void cselib_record_set PARAMS ((rtx, cselib_val *,
+ cselib_val *));
+static void cselib_record_sets PARAMS ((rtx));
+
+/* There are three ways in which cselib can look up an rtx:
+ - for a REG, the reg_values table (which is indexed by regno) is used
+ - for a MEM, we recursively look up its address and then follow the
+ addr_list of that value
+ - for everything else, we compute a hash value and go through the hash
+ table. Since different rtx's can still have the same hash value,
+ this involves walking the table entries for a given value and comparing
+ the locations of the entries with the rtx we are looking up. */
+
+/* A table that enables us to look up elts by their value. */
+static htab_t hash_table;
+
+/* This is a global so we don't have to pass this through every function.
+ It is used in new_elt_loc_list to set SETTING_INSN. */
+static rtx cselib_current_insn;
+
+/* Every new unknown value gets a unique number. */
+static unsigned int next_unknown_value;
+/* The number of registers we had when the varrays were last resized. */
+static unsigned int cselib_nregs;
+
+/* Count values without known locations. Whenever this grows too big, we
+ remove these useless values from the table. */
+static int n_useless_values;
+
+/* Number of useless values before we remove them from the hash table. */
+#define MAX_USELESS_VALUES 32
+
+/* This table maps from register number to values. It does not contain
+ pointers to cselib_val structures, but rather elt_lists. The purpose is
+ to be able to refer to the same register in different modes. */
+static varray_type reg_values;
+#define REG_VALUES(I) VARRAY_ELT_LIST (reg_values, (I))
+
+/* We pass this to cselib_invalidate_mem to invalidate all of
+ memory for a non-const call instruction. */
+static rtx callmem;
+
+/* Memory for our structures is allocated from this obstack. */
+static struct obstack cselib_obstack;
+
+/* Used to quickly free all memory. */
+static char *cselib_startobj;
+
+/* Caches for unused structures. */
+static cselib_val *empty_vals;
+static struct elt_list *empty_elt_lists;
+static struct elt_loc_list *empty_elt_loc_lists;
+
+/* Set by discard_useless_locs if it deleted the last location of any
+ value. */
+static int values_became_useless;
+\f
/* Make a binary operation by properly ordering the operands and
seeing if the expression folds. */
enum machine_mode mode, op0_mode;
rtx op0, op1, op2;
{
- int width = GET_MODE_BITSIZE (mode);
+ unsigned int width = GET_MODE_BITSIZE (mode);
/* VOIDmode means "infinite" precision. */
if (width == 0)
return op2;
else if (GET_RTX_CLASS (GET_CODE (op0)) == '<' && ! side_effects_p (op0))
{
- rtx temp;
- temp = simplify_relational_operation (GET_CODE (op0), op0_mode,
- XEXP (op0, 0), XEXP (op0, 1));
+ rtx temp
+ = simplify_relational_operation (GET_CODE (op0), op0_mode,
+ XEXP (op0, 0), XEXP (op0, 1));
+
/* See if any simplifications were possible. */
if (temp == const0_rtx)
return op2;
}
}
\f
-static int entry_and_rtx_equal_p PARAMS ((const void *, const void *));
-static unsigned int get_value_hash PARAMS ((const void *));
-static struct elt_list *new_elt_list PARAMS ((struct elt_list *, cselib_val *));
-static struct elt_loc_list *new_elt_loc_list PARAMS ((struct elt_loc_list *, rtx));
-static void unchain_one_value PARAMS ((cselib_val *));
-static void unchain_one_elt_list PARAMS ((struct elt_list **));
-static void unchain_one_elt_loc_list PARAMS ((struct elt_loc_list **));
-static void clear_table PARAMS ((void));
-static int check_value_useless PARAMS ((cselib_val *));
-static int discard_useless_locs PARAMS ((void **, void *));
-static int discard_useless_values PARAMS ((void **, void *));
-static void remove_useless_values PARAMS ((void));
-static unsigned int hash_rtx PARAMS ((rtx, enum machine_mode, int));
-static cselib_val *new_cselib_val PARAMS ((unsigned int,
- enum machine_mode));
-static void add_mem_for_addr PARAMS ((cselib_val *, cselib_val *,
- rtx));
-static cselib_val *cselib_lookup_mem PARAMS ((rtx, int));
-static rtx cselib_subst_to_values PARAMS ((rtx));
-static void cselib_invalidate_regno PARAMS ((unsigned int,
- enum machine_mode));
-static int cselib_mem_conflict_p PARAMS ((rtx, rtx));
-static int cselib_invalidate_mem_1 PARAMS ((void **, void *));
-static void cselib_invalidate_mem PARAMS ((rtx));
-static void cselib_invalidate_rtx PARAMS ((rtx, rtx, void *));
-static void cselib_record_set PARAMS ((rtx, cselib_val *,
- cselib_val *));
-static void cselib_record_sets PARAMS ((rtx));
-
-/* There are three ways in which cselib can look up an rtx:
- - for a REG, the reg_values table (which is indexed by regno) is used
- - for a MEM, we recursively look up its address and then follow the
- addr_list of that value
- - for everything else, we compute a hash value and go through the hash
- table. Since different rtx's can still have the same hash value,
- this involves walking the table entries for a given value and comparing
- the locations of the entries with the rtx we are looking up. */
-
-/* A table that enables us to look up elts by their value. */
-static htab_t hash_table;
-
-/* This is a global so we don't have to pass this through every function.
- It is used in new_elt_loc_list to set SETTING_INSN. */
-static rtx cselib_current_insn;
-
-/* Every new unknown value gets a unique number. */
-static unsigned int next_unknown_value;
-
-/* The number of registers we had when the varrays were last resized. */
-static int cselib_nregs;
-
-/* Count values without known locations. Whenever this grows too big, we
- remove these useless values from the table. */
-static int n_useless_values;
-
-/* Number of useless values before we remove them from the hash table. */
-#define MAX_USELESS_VALUES 32
-
-/* This table maps from register number to values. It does not contain
- pointers to cselib_val structures, but rather elt_lists. The purpose is
- to be able to refer to the same register in different modes. */
-static varray_type reg_values;
-#define REG_VALUES(I) VARRAY_ELT_LIST (reg_values, (I))
-
-/* We pass this to cselib_invalidate_mem to invalidate all of
- memory for a non-const call instruction. */
-static rtx callmem;
-
-/* Memory for our structures is allocated from this obstack. */
-static struct obstack cselib_obstack;
-
-/* Used to quickly free all memory. */
-static char *cselib_startobj;
-
-/* Caches for unused structures. */
-static cselib_val *empty_vals;
-static struct elt_list *empty_elt_lists;
-static struct elt_loc_list *empty_elt_loc_lists;
/* Allocate a struct elt_list and fill in its two elements with the
arguments. */
+
static struct elt_list *
new_elt_list (next, elt)
struct elt_list *next;
cselib_val *elt;
{
struct elt_list *el = empty_elt_lists;
+
if (el)
empty_elt_lists = el->next;
else
/* Allocate a struct elt_loc_list and fill in its two elements with the
arguments. */
+
static struct elt_loc_list *
new_elt_loc_list (next, loc)
struct elt_loc_list *next;
rtx loc;
{
struct elt_loc_list *el = empty_elt_loc_lists;
+
if (el)
empty_elt_loc_lists = el->next;
else
/* The elt_list at *PL is no longer needed. Unchain it and free its
storage. */
+
static void
unchain_one_elt_list (pl)
struct elt_list **pl;
{
struct elt_list *l = *pl;
+
*pl = l->next;
l->next = empty_elt_lists;
empty_elt_lists = l;
}
/* Likewise for elt_loc_lists. */
+
static void
unchain_one_elt_loc_list (pl)
struct elt_loc_list **pl;
{
struct elt_loc_list *l = *pl;
+
*pl = l->next;
l->next = empty_elt_loc_lists;
empty_elt_loc_lists = l;
/* Likewise for cselib_vals. This also frees the addr_list associated with
V. */
+
static void
unchain_one_value (v)
cselib_val *v;
/* Remove all entries from the hash table. Also used during
initialization. */
+
static void
clear_table ()
{
- int i;
+ unsigned int i;
+
for (i = 0; i < cselib_nregs; i++)
REG_VALUES (i) = 0;
/* The equality test for our hash table. The first argument ENTRY is a table
element (i.e. a cselib_val), while the second arg X is an rtx. */
+
static int
entry_and_rtx_equal_p (entry, x_arg)
const void *entry, *x_arg;
{
struct elt_loc_list *l;
- const cselib_val *v = (const cselib_val *)entry;
- rtx x = (rtx)x_arg;
+ const cselib_val *v = (const cselib_val *) entry;
+ rtx x = (rtx) x_arg;
/* We don't guarantee that distinct rtx's have different hash values,
so we need to do a comparison. */
for (l = v->locs; l; l = l->next)
if (rtx_equal_for_cselib_p (l->loc, x))
return 1;
+
return 0;
}
/* The hash function for our hash table. The value is always computed with
hash_rtx when adding an element; this function just extracts the hash
value from a cselib_val structure. */
+
static unsigned int
get_value_hash (entry)
const void *entry;
/* If there are no more locations that hold a value, the value has become
useless. See whether that is the case for V. Return 1 if this has
just become useless. */
+
static int
check_value_useless (v)
cselib_val *v;
only return true for values which point to a cselib_val whose value
element has been set to zero, which implies the cselib_val will be
removed. */
+
int
references_value_p (x, only_useless)
rtx x;
{
enum rtx_code code = GET_CODE (x);
const char *fmt = GET_RTX_FORMAT (code);
- int i;
+ int i, j;
if (GET_CODE (x) == VALUE
&& (! only_useless || CSELIB_VAL_PTR (x)->value == 0))
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
- if (fmt[i] == 'e')
- {
- if (references_value_p (XEXP (x, i), only_useless))
- return 1;
- }
+ if (fmt[i] == 'e' && references_value_p (XEXP (x, i), only_useless))
+ return 1;
else if (fmt[i] == 'E')
- {
- int j;
-
- for (j = 0; j < XVECLEN (x, i); j++)
- if (references_value_p (XVECEXP (x, i, j), only_useless))
- return 1;
- }
+ for (j = 0; j < XVECLEN (x, i); j++)
+ if (references_value_p (XVECEXP (x, i, j), only_useless))
+ return 1;
}
return 0;
}
-/* Set by discard_useless_locs if it deleted the last location of any
- value. */
-static int values_became_useless;
-
/* For all locations found in X, delete locations that reference useless
values (i.e. values without any location). Called through
htab_traverse. */
+
static int
discard_useless_locs (x, info)
void **x;
else
p = &(*p)->next;
}
+
if (check_value_useless (v))
values_became_useless = 1;
unchain_one_value (v);
n_useless_values--;
}
+
return 1;
}
/* Clean out useless values (i.e. those which no longer have locations
associated with them) from the hash table. */
+
static void
remove_useless_values ()
{
/* Return nonzero if we can prove that X and Y contain the same value, taking
our gathered information into account. */
+
int
rtx_equal_for_cselib_p (x, y)
rtx x, y;
if (GET_CODE (x) == REG || GET_CODE (x) == MEM)
{
cselib_val *e = cselib_lookup (x, VOIDmode, 0);
+
if (e)
x = e->u.val_rtx;
}
+
if (GET_CODE (y) == REG || GET_CODE (y) == MEM)
{
cselib_val *e = cselib_lookup (y, VOIDmode, 0);
+
if (e)
y = e->u.val_rtx;
}
/* Avoid infinite recursion. */
if (GET_CODE (t) == REG || GET_CODE (t) == MEM)
continue;
-
- if (rtx_equal_for_cselib_p (t, y))
+ else if (rtx_equal_for_cselib_p (t, y))
return 1;
}
if (GET_CODE (t) == REG || GET_CODE (t) == MEM)
continue;
-
- if (rtx_equal_for_cselib_p (x, t))
+ else if (rtx_equal_for_cselib_p (x, t))
return 1;
}
return 0;
}
- if (GET_CODE (x) != GET_CODE (y)
- || GET_MODE (x) != GET_MODE (y))
+ if (GET_CODE (x) != GET_CODE (y) || GET_MODE (x) != GET_MODE (y))
return 0;
/* This won't be handled correctly by the code below. */
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
int j;
+
switch (fmt[i])
{
case 'w':
CREATE is nonzero, table elts are created for regs and mem.
MODE is used in hashing for CONST_INTs only;
otherwise the mode of X is used. */
+
static unsigned int
hash_rtx (x, mode, create)
rtx x;
e = cselib_lookup (x, GET_MODE (x), create);
if (! e)
return 0;
+
hash += e->value;
return hash;
case CONST_INT:
- {
- unsigned HOST_WIDE_INT tem = INTVAL (x);
- hash += ((unsigned) CONST_INT << 7) + (unsigned) mode + tem;
- return hash ? hash : CONST_INT;
- }
+ hash += ((unsigned) CONST_INT << 7) + (unsigned) mode + INTVAL (x);
+ return hash ? hash : CONST_INT;
case CONST_DOUBLE:
/* This is like the general case, except that it only counts
hash += (unsigned) code + (unsigned) GET_MODE (x);
if (GET_MODE (x) != VOIDmode)
for (i = 2; i < GET_RTX_LENGTH (CONST_DOUBLE); i++)
- {
- unsigned HOST_WIDE_INT tem = XWINT (x, i);
- hash += tem;
- }
+ hash += XWINT (x, i);
else
hash += ((unsigned) CONST_DOUBLE_LOW (x)
+ (unsigned) CONST_DOUBLE_HIGH (x));
{
if (fmt[i] == 'e')
{
- unsigned int tem_hash;
rtx tem = XEXP (x, i);
+ unsigned int tem_hash;
/* If we are about to do the last recursive call
needed at this level, change it into iteration.
x = tem;
goto repeat;
}
+
tem_hash = hash_rtx (tem, 0, create);
if (tem_hash == 0)
return 0;
+
hash += tem_hash;
}
else if (fmt[i] == 'E')
for (j = 0; j < XVECLEN (x, i); j++)
{
unsigned int tem_hash = hash_rtx (XVECEXP (x, i, j), 0, create);
+
if (tem_hash == 0)
return 0;
+
hash += tem_hash;
}
else if (fmt[i] == 's')
{
const unsigned char *p = (const unsigned char *) XSTR (x, i);
+
if (p)
while (*p)
hash += *p++;
}
else if (fmt[i] == 'i')
- {
- unsigned int tem = XINT (x, i);
- hash += tem;
- }
+ hash += XINT (x, i);
else if (fmt[i] == '0' || fmt[i] == 't')
/* unused */;
else
abort ();
}
+
return hash ? hash : 1 + GET_CODE (x);
}
/* Create a new value structure for VALUE and initialize it. The mode of the
value is MODE. */
+
static cselib_val *
new_cselib_val (value, mode)
unsigned int value;
enum machine_mode mode;
{
cselib_val *e = empty_vals;
+
if (e)
empty_vals = e->u.next_free;
else
e = (cselib_val *) obstack_alloc (&cselib_obstack, sizeof (cselib_val));
+
if (value == 0)
abort ();
+
e->value = value;
e->u.val_rtx = gen_rtx_VALUE (mode);
CSELIB_VAL_PTR (e->u.val_rtx) = e;
-
e->addr_list = 0;
e->locs = 0;
return e;
/* ADDR_ELT is a value that is used as address. MEM_ELT is the value that
contains the data at this address. X is a MEM that represents the
value. Update the two value structures to represent this situation. */
+
static void
add_mem_for_addr (addr_elt, mem_elt, x)
cselib_val *addr_elt, *mem_elt;
/* Subroutine of cselib_lookup. Return a value for X, which is a MEM rtx.
If CREATE, make a new one if we haven't seen it before. */
+
static cselib_val *
cselib_lookup_mem (x, create)
rtx x;
cselib_val *mem_elt;
struct elt_list *l;
- if (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode)
- return 0;
- if (FLOAT_MODE_P (GET_MODE (x)) && flag_float_store)
+ if (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode
+ || (FLOAT_MODE_P (GET_MODE (x)) && flag_float_store))
return 0;
/* Look up the value for the address. */
for (l = addr->addr_list; l; l = l->next)
if (GET_MODE (l->elt->u.val_rtx) == GET_MODE (x))
return l->elt;
+
if (! create)
return 0;
+
mem_elt = new_cselib_val (++next_unknown_value, GET_MODE (x));
add_mem_for_addr (addr, mem_elt, x);
slot = htab_find_slot_with_hash (hash_table, x, mem_elt->value, 1);
to registers and memory.
X isn't actually modified; if modifications are needed, new rtl is
allocated. However, the return value can share rtl with X. */
+
static rtx
cselib_subst_to_values (x)
rtx x;
switch (code)
{
case REG:
- i = REGNO (x);
- for (l = REG_VALUES (i); l; l = l->next)
+ for (l = REG_VALUES (REGNO (x)); l; l = l->next)
if (GET_MODE (l->elt->u.val_rtx) == GET_MODE (x))
return l->elt->u.val_rtx;
+
abort ();
case MEM:
if (fmt[i] == 'e')
{
rtx t = cselib_subst_to_values (XEXP (x, i));
+
if (t != XEXP (x, i) && x == copy)
copy = shallow_copy_rtx (x);
+
XEXP (copy, i) = t;
}
else if (fmt[i] == 'E')
for (j = 0; j < XVECLEN (x, i); j++)
{
rtx t = cselib_subst_to_values (XVECEXP (x, i, j));
+
if (t != XVECEXP (x, i, j) && XVEC (x, i) == XVEC (copy, i))
{
if (x == copy)
copy = shallow_copy_rtx (x);
+
XVEC (copy, i) = rtvec_alloc (XVECLEN (x, i));
for (k = 0; k < j; k++)
XVECEXP (copy, i, k) = XVECEXP (x, i, k);
}
+
XVECEXP (copy, i, j) = t;
}
}
}
+
return copy;
}
If CREATE is zero, we return NULL if we don't know the value. Otherwise,
we create a new one if possible, using mode MODE if X doesn't have a mode
(i.e. because it's a constant). */
+
cselib_val *
cselib_lookup (x, mode, create)
rtx x;
if (GET_CODE (x) == REG)
{
struct elt_list *l;
- int i = REGNO (x);
+ unsigned int i = REGNO (x);
+
for (l = REG_VALUES (i); l; l = l->next)
if (mode == GET_MODE (l->elt->u.val_rtx))
return l->elt;
+
if (! create)
return 0;
+
e = new_cselib_val (++next_unknown_value, GET_MODE (x));
e->locs = new_elt_loc_list (e->locs, x);
REG_VALUES (i) = new_elt_list (REG_VALUES (i), e);
slot = htab_find_slot_with_hash (hash_table, x, hashval, create);
if (slot == 0)
return 0;
+
e = (cselib_val *) *slot;
if (e)
return e;
e = new_cselib_val (hashval, mode);
+
/* We have to fill the slot before calling cselib_subst_to_values:
the hash table is inconsistent until we do so, and
cselib_subst_to_values will need to do lookups. */
break;
}
}
+
check_value_useless (v);
}
}
/* The memory at address MEM_BASE is being changed.
Return whether this change will invalidate VAL. */
+
static int
cselib_mem_conflict_p (mem_base, val)
rtx mem_base;
{
enum rtx_code code;
const char *fmt;
- int i;
+ int i, j;
code = GET_CODE (val);
switch (code)
case MEM:
if (GET_MODE (mem_base) == BLKmode
- || GET_MODE (val) == BLKmode)
- return 1;
- if (anti_dependence (val, mem_base))
+ || GET_MODE (val) == BLKmode
+ || anti_dependence (val, mem_base))
return 1;
+
/* The address may contain nested MEMs. */
break;
}
fmt = GET_RTX_FORMAT (code);
-
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
return 1;
}
else if (fmt[i] == 'E')
- {
- int j;
-
- for (j = 0; j < XVECLEN (val, i); j++)
- if (cselib_mem_conflict_p (mem_base, XVECEXP (val, i, j)))
- return 1;
- }
+ for (j = 0; j < XVECLEN (val, i); j++)
+ if (cselib_mem_conflict_p (mem_base, XVECEXP (val, i, j)))
+ return 1;
}
return 0;
/* For the value found in SLOT, walk its locations to determine if any overlap
INFO (which is a MEM rtx). */
+
static int
cselib_invalidate_mem_1 (slot, info)
void **slot;
while (*p)
{
+ rtx x = (*p)->loc;
cselib_val *addr;
struct elt_list **mem_chain;
- rtx x = (*p)->loc;
/* MEMs may occur in locations only at the top level; below
that every MEM or REG is substituted by its VALUE. */
unchain_one_elt_list (mem_chain);
break;
}
+
mem_chain = &(*mem_chain)->next;
}
+
unchain_one_elt_loc_list (p);
}
+
check_value_useless (v);
return 1;
}
/* Invalidate any locations in the table which are changed because of a
store to MEM_RTX. If this is called because of a non-const call
instruction, MEM_RTX is (mem:BLK const0_rtx). */
+
static void
cselib_invalidate_mem (mem_rtx)
rtx mem_rtx;
/* Invalidate DEST, which is being assigned to or clobbered. The second and
the third parameter exist so that this function can be passed to
note_stores; they are ignored. */
+
static void
cselib_invalidate_rtx (dest, ignore, data)
rtx dest;
rtx ignore ATTRIBUTE_UNUSED;
void *data ATTRIBUTE_UNUSED;
{
- while (GET_CODE (dest) == STRICT_LOW_PART
- || GET_CODE (dest) == SIGN_EXTRACT
- || GET_CODE (dest) == ZERO_EXTRACT
- || GET_CODE (dest) == SUBREG)
+ while (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == SIGN_EXTRACT
+ || GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SUBREG)
dest = XEXP (dest, 0);
if (GET_CODE (dest) == REG)
}
/* Record the effects of INSN. */
+
void
cselib_process_insn (insn)
rtx insn;
{
int i;
+ rtx x;
cselib_current_insn = insn;
cselib_current_insn = 0;
return;
}
+
/* If this is a call instruction, forget anything stored in a
call clobbered register, or, if this is not a const call, in
memory. */
/* Clobber any registers which appear in REG_INC notes. We
could keep track of the changes to their values, but it is
unlikely to help. */
- {
- rtx x;
-
- for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
- if (REG_NOTE_KIND (x) == REG_INC)
- cselib_invalidate_rtx (XEXP (x, 0), NULL_RTX, NULL);
- }
+ for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
+ if (REG_NOTE_KIND (x) == REG_INC)
+ cselib_invalidate_rtx (XEXP (x, 0), NULL_RTX, NULL);
#endif
/* Look for any CLOBBERs in CALL_INSN_FUNCTION_USAGE, but only
after we have processed the insn. */
if (GET_CODE (insn) == CALL_INSN)
- {
- rtx x;
-
- for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
- if (GET_CODE (XEXP (x, 0)) == CLOBBER)
- cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0), NULL_RTX,
- NULL);
- }
+ for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
+ if (GET_CODE (XEXP (x, 0)) == CLOBBER)
+ cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0), NULL_RTX, NULL);
cselib_current_insn = 0;
/* Make sure our varrays are big enough. Not called from any cselib routines;
it must be called by the user if it allocated new registers. */
+
void
cselib_update_varray_sizes ()
{
- int nregs = max_reg_num ();
+ unsigned int nregs = max_reg_num ();
+
if (nregs == cselib_nregs)
return;
+
cselib_nregs = nregs;
VARRAY_GROW (reg_values, nregs);
}
/* Initialize cselib for one pass. The caller must also call
init_alias_analysis. */
+
void
cselib_init ()
{
if (! callmem)
{
extern struct obstack permanent_obstack;
+
gcc_obstack_init (&cselib_obstack);
cselib_startobj = obstack_alloc (&cselib_obstack, 0);
}
/* Called when the current user is done with cselib. */
+
void
cselib_finish ()
{
OSDN Git Service
