* varray.h (struct const_equiv_data): New type.
(union varray_data_tag): New element const_equiv.
(VARRAY_CONST_EQUIV_INIT, VARRAY_CONST_EQUIV): New macros.
(VARRAY_SIZE): New macro, returns number of elements.
* integrate.h: Include varray.h.
(struct inline_remap): Replace const_equiv_map, const_age_map and
const_equiv_map_size with a const_equiv_varray element.
(MAYBE_EXTEND_CONST_EQUIV_VARRAY): New macro; grows varray if needed.
(SET_CONST_EQUIV_DATA): New macro; sets rtx and age fields simultaneously,
growing the varray if needed.
* integrate.c (global_const_equiv_map, global_const_equiv_map_size): Deleted,
replaced by....
(global_const_equiv_varray): New variable.
(expand_inline_function): References changed.
* integrate.h: Update declarations.
* integrate.c (process_reg_parm, expand_inline_function,
copy_rtx_and_substitute, try_constants, subst_constants, mark_stores): Use
varray allocation and accessor macros, new integrate.h macros, and
global_const_equiv_varray. Don't conditionalize non-NULL stores on array size;
instead, expand the array as needed.
* unroll.c (unroll_loop): Likewise.
* unroll.c (unroll_loop): Initialize const_equiv_varray element to zero. After
allocating varray, always exit through bottom of function, where it can be
deallocated if needed. Don't explicitly reallocate const_equiv_map storage;
instead, just ensure the varray has been initialized, and update the global
reference.
From-SVN: r24956
+Mon Feb 1 15:00:02 1999 Ken Raeburn <raeburn@cygnus.com>
+
+ Use varrays for constant-equivalence data:
+
+ * varray.h (struct const_equiv_data): New type.
+ (union varray_data_tag): New element const_equiv.
+ (VARRAY_CONST_EQUIV_INIT, VARRAY_CONST_EQUIV): New macros.
+ (VARRAY_SIZE): New macro, returns number of elements.
+ * integrate.h: Include varray.h.
+ (struct inline_remap): Replace const_equiv_map, const_age_map and
+ const_equiv_map_size with a const_equiv_varray element.
+ (MAYBE_EXTEND_CONST_EQUIV_VARRAY): New macro; grows varray if
+ needed.
+ (SET_CONST_EQUIV_DATA): New macro; sets rtx and age fields
+ simultaneously, growing the varray if needed.
+
+ * integrate.c (global_const_equiv_map,
+ global_const_equiv_map_size): Deleted, replaced by....
+ (global_const_equiv_varray): New variable.
+ (expand_inline_function): References changed.
+ * integrate.h: Update declarations.
+
+ * integrate.c (process_reg_parm, expand_inline_function,
+ copy_rtx_and_substitute, try_constants, subst_constants,
+ mark_stores): Use varray allocation and accessor macros, new
+ integrate.h macros, and global_const_equiv_varray. Don't
+ conditionalize non-NULL stores on array size; instead, expand the
+ array as needed.
+ * unroll.c (unroll_loop): Likewise.
+
+ * unroll.c (unroll_loop): Initialize const_equiv_varray element to
+ zero. After allocating varray, always exit through bottom of
+ function, where it can be deallocated if needed. Don't explicitly
+ reallocate const_equiv_map storage; instead, just ensure the
+ varray has been initialized, and update the global reference.
+
Mon Feb 1 09:40:25 1999 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* system.h (inline, const): Handle these for stage2 (and later) gcc.
with a function called from note_stores. Be *very* careful that this
is used properly in the presence of recursion. */
-rtx *global_const_equiv_map;
-int global_const_equiv_map_size;
+varray_type global_const_equiv_varray;
\f
#define FIXED_BASE_PLUS_P(X) \
(GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \
{
rtx temp = copy_to_mode_reg (GET_MODE (loc), copy);
REG_USERVAR_P (temp) = REG_USERVAR_P (loc);
- if ((CONSTANT_P (copy) || FIXED_BASE_PLUS_P (copy))
- && REGNO (temp) < map->const_equiv_map_size)
- {
- map->const_equiv_map[REGNO (temp)] = copy;
- map->const_age_map[REGNO (temp)] = CONST_AGE_PARM;
- }
+ if (CONSTANT_P (copy) || FIXED_BASE_PLUS_P (copy))
+ SET_CONST_EQUIV_DATA (map, temp, copy, CONST_AGE_PARM);
copy = temp;
}
map->reg_map[REGNO (loc)] = copy;
rtx loc;
rtx stack_save = 0;
rtx temp;
- struct inline_remap *map;
+ struct inline_remap *map = 0;
#ifdef HAVE_cc0
rtx cc0_insn = 0;
#endif
map->integrating = 1;
- /* const_equiv_map maps pseudos in our routine to constants, so it needs to
- be large enough for all our pseudos. This is the number we are currently
- using plus the number in the called routine, plus 15 for each arg,
- five to compute the virtual frame pointer, and five for the return value.
- This should be enough for most cases. We do not reference entries
- outside the range of the map.
+ /* const_equiv_varray maps pseudos in our routine to constants, so
+ it needs to be large enough for all our pseudos. This is the
+ number we are currently using plus the number in the called
+ routine, plus 15 for each arg, five to compute the virtual frame
+ pointer, and five for the return value. This should be enough
+ for most cases. We do not reference entries outside the range of
+ the map.
??? These numbers are quite arbitrary and were obtained by
experimentation. At some point, we should try to allocate the
table after all the parameters are set up so we an more accurately
estimate the number of pseudos we will need. */
- map->const_equiv_map_size
- = max_reg_num () + (max_regno - FIRST_PSEUDO_REGISTER) + 15 * nargs + 10;
-
- map->const_equiv_map
- = (rtx *)alloca (map->const_equiv_map_size * sizeof (rtx));
- bzero ((char *) map->const_equiv_map,
- map->const_equiv_map_size * sizeof (rtx));
-
- map->const_age_map
- = (unsigned *)alloca (map->const_equiv_map_size * sizeof (unsigned));
- bzero ((char *) map->const_age_map,
- map->const_equiv_map_size * sizeof (unsigned));
+ VARRAY_CONST_EQUIV_INIT (map->const_equiv_varray,
+ (max_reg_num ()
+ + (max_regno - FIRST_PSEUDO_REGISTER)
+ + 15 * nargs
+ + 10),
+ "expand_inline_function");
map->const_age = 0;
/* Record the current insn in case we have to set up pointers to frame
if (GET_CODE (copy) != REG)
{
temp = copy_addr_to_reg (copy);
- if ((CONSTANT_P (copy) || FIXED_BASE_PLUS_P (copy))
- && REGNO (temp) < map->const_equiv_map_size)
- {
- map->const_equiv_map[REGNO (temp)] = copy;
- map->const_age_map[REGNO (temp)] = CONST_AGE_PARM;
- }
+ if (CONSTANT_P (copy) || FIXED_BASE_PLUS_P (copy))
+ SET_CONST_EQUIV_DATA (map, temp, copy, CONST_AGE_PARM);
copy = temp;
}
map->reg_map[REGNO (XEXP (loc, 0))] = copy;
temp = force_reg (Pmode, temp);
map->reg_map[REGNO (XEXP (loc, 0))] = temp;
- if ((CONSTANT_P (structure_value_addr)
- || GET_CODE (structure_value_addr) == ADDRESSOF
- || (GET_CODE (structure_value_addr) == PLUS
- && (XEXP (structure_value_addr, 0)
- == virtual_stack_vars_rtx)
- && (GET_CODE (XEXP (structure_value_addr, 1))
- == CONST_INT)))
- && REGNO (temp) < map->const_equiv_map_size)
+ if (CONSTANT_P (structure_value_addr)
+ || GET_CODE (structure_value_addr) == ADDRESSOF
+ || (GET_CODE (structure_value_addr) == PLUS
+ && (XEXP (structure_value_addr, 0)
+ == virtual_stack_vars_rtx)
+ && (GET_CODE (XEXP (structure_value_addr, 1))
+ == CONST_INT)))
{
- map->const_equiv_map[REGNO (temp)] = structure_value_addr;
- map->const_age_map[REGNO (temp)] = CONST_AGE_PARM;
+ SET_CONST_EQUIV_DATA (map, temp, structure_value_addr,
+ CONST_AGE_PARM);
}
}
else
/* Clean up stack so that variables might have smaller offsets. */
do_pending_stack_adjust ();
- /* Save a copy of the location of const_equiv_map for mark_stores, called
- via note_stores. */
- global_const_equiv_map = map->const_equiv_map;
- global_const_equiv_map_size = map->const_equiv_map_size;
+ /* Save a copy of the location of const_equiv_varray for
+ mark_stores, called via note_stores. */
+ global_const_equiv_varray = map->const_equiv_varray;
/* If the called function does an alloca, save and restore the
stack pointer around the call. This saves stack space, but
/* Be lazy and assume CALL_INSNs clobber all hard registers. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- map->const_equiv_map[i] = 0;
+ VARRAY_CONST_EQUIV (map->const_equiv_varray, i).rtx = 0;
break;
case CODE_LABEL:
/* Make sure we free the things we explicitly allocated with xmalloc. */
if (real_label_map)
free (real_label_map);
+ if (map)
+ VARRAY_FREE (map->const_equiv_varray);
return target;
}
STACK_BOUNDARY / BITS_PER_UNIT);
#endif
- if (REGNO (temp) < map->const_equiv_map_size)
- {
- map->const_equiv_map[REGNO (temp)] = loc;
- map->const_age_map[REGNO (temp)] = CONST_AGE_PARM;
- }
+ SET_CONST_EQUIV_DATA (map, temp, loc, CONST_AGE_PARM);
seq = gen_sequence ();
end_sequence ();
STACK_BOUNDARY / BITS_PER_UNIT);
#endif
- if (REGNO (temp) < map->const_equiv_map_size)
- {
- map->const_equiv_map[REGNO (temp)] = loc;
- map->const_age_map[REGNO (temp)] = CONST_AGE_PARM;
- }
+ SET_CONST_EQUIV_DATA (map, temp, loc, CONST_AGE_PARM);
seq = gen_sequence ();
end_sequence ();
copy_rtx_and_substitute (SET_DEST (orig), map);
equiv_reg = map->reg_map[REGNO (SET_DEST (orig))];
- equiv_loc = map->const_equiv_map[REGNO (equiv_reg)];
+ equiv_loc = VARRAY_CONST_EQUIV (map->const_equiv_varray, REGNO (equiv_reg)).rtx;
loc_offset
= GET_CODE (equiv_loc) == REG ? 0 : INTVAL (XEXP (equiv_loc, 1));
return gen_rtx_SET (VOIDmode, SET_DEST (orig),
{
int regno = REGNO (map->equiv_sets[i].dest);
- if (regno < map->const_equiv_map_size
- && (map->const_equiv_map[regno] == 0
- /* Following clause is a hack to make case work where GNU C++
- reassigns a variable to make cse work right. */
- || ! rtx_equal_p (map->const_equiv_map[regno],
- map->equiv_sets[i].equiv)))
- {
- map->const_equiv_map[regno] = map->equiv_sets[i].equiv;
- map->const_age_map[regno] = map->const_age;
- }
+ MAYBE_EXTEND_CONST_EQUIV_VARRAY (map, regno);
+ if (VARRAY_CONST_EQUIV (map->const_equiv_varray, regno).rtx == 0
+ /* Following clause is a hack to make case work where GNU C++
+ reassigns a variable to make cse work right. */
+ || ! rtx_equal_p (VARRAY_CONST_EQUIV (map->const_equiv_varray,
+ regno).rtx,
+ map->equiv_sets[i].equiv))
+ SET_CONST_EQUIV_DATA (map, map->equiv_sets[i].dest,
+ map->equiv_sets[i].equiv, map->const_age);
}
else if (map->equiv_sets[i].dest == pc_rtx)
map->last_pc_value = map->equiv_sets[i].equiv;
hard regs used as user variables with constants. */
{
int regno = REGNO (x);
+ struct const_equiv_data *p;
if (! (regno < FIRST_PSEUDO_REGISTER && REG_USERVAR_P (x))
- && regno < map->const_equiv_map_size
- && map->const_equiv_map[regno] != 0
- && map->const_age_map[regno] >= map->const_age)
- validate_change (insn, loc, map->const_equiv_map[regno], 1);
+ && regno < VARRAY_SIZE (map->const_equiv_varray)
+ && (p = &VARRAY_CONST_EQUIV (map->const_equiv_varray, regno),
+ p->rtx != 0)
+ && p->age >= map->const_age)
+ validate_change (insn, loc, p->rtx, 1);
return;
}
if (regno != VIRTUAL_INCOMING_ARGS_REGNUM
&& regno != VIRTUAL_STACK_VARS_REGNUM)
for (i = regno; i <= last_reg; i++)
- if (i < global_const_equiv_map_size)
- global_const_equiv_map[i] = 0;
+ if (i < VARRAY_SIZE (global_const_equiv_varray))
+ VARRAY_CONST_EQUIV (global_const_equiv_varray, i).rtx = 0;
}
}
\f
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include "varray.h"
+
/* This structure is used to remap objects in the function being inlined to
those belonging to the calling function. It is passed by
expand_inline_function to its children.
pseudos that contain pointers into the replacement area allocated for
this inline instance. These pseudos are then marked as being equivalent
to the appropriate address and substituted if valid. */
- rtx *const_equiv_map;
- /* Number of entries in const_equiv_map and const_arg_map. */
- int const_equiv_map_size;
+ varray_type const_equiv_varray;
/* This is incremented for each new basic block.
- It is used to store in const_age_map to record the domain of validity
- of each entry in const_equiv_map.
+ It is used to store in the age field to record the domain of validity
+ of each entry in const_equiv_varray.
A value of -1 indicates an entry for a reg which is a parm.
All other values are "positive". */
#define CONST_AGE_PARM (-1)
unsigned int const_age;
- /* In parallel with const_equiv_map, record the valid age for each entry.
- The entry is invalid if its age is less than const_age. */
- unsigned int *const_age_map;
+
/* Target of the inline function being expanded, or NULL if none. */
rtx inline_target;
/* When an insn is being copied by copy_rtx_and_substitute,
/* Set the label indicated. */
#define set_label_in_map(MAP, I, X) ((MAP)->label_map[I] = (X))
-/* Unfortunately, we need a global copy of const_equiv map for communication
- with a function called from note_stores. Be *very* careful that this
- is used properly in the presence of recursion. */
-
-extern rtx *global_const_equiv_map;
-extern int global_const_equiv_map_size;
+/* Unfortunately, we need a global copy of const_equiv varray for
+ communication with a function called from note_stores. Be *very*
+ careful that this is used properly in the presence of recursion. */
+
+extern varray_type global_const_equiv_varray;
+
+#define MAYBE_EXTEND_CONST_EQUIV_VARRAY(MAP,MAX) \
+ { \
+ if ((MAX) >= VARRAY_SIZE ((MAP)->const_equiv_varray)) \
+ { \
+ int is_global = (global_const_equiv_varray \
+ == (MAP)->const_equiv_varray); \
+ VARRAY_GROW ((MAP)->const_equiv_varray, (MAX)+1); \
+ if (is_global) \
+ global_const_equiv_varray = (MAP)->const_equiv_varray; \
+ } \
+ }
+
+#define SET_CONST_EQUIV_DATA(MAP,REG,RTX,AGE) \
+ { \
+ struct const_equiv_data *p; \
+ MAYBE_EXTEND_CONST_EQUIV_VARRAY ((MAP), REGNO (REG)); \
+ p = &VARRAY_CONST_EQUIV ((MAP)->const_equiv_varray, REGNO (REG)); \
+ p->rtx = (RTX); \
+ p->age = (AGE); \
+ }
char *local_label;
char *local_regno;
int maxregnum;
- int new_maxregnum;
rtx exit_label = 0;
rtx start_label;
struct iv_class *bl;
map = (struct inline_remap *) alloca (sizeof (struct inline_remap));
map->integrating = 0;
+ map->const_equiv_varray = 0;
/* Allocate the label map. */
map->reg_map = (rtx *) alloca (maxregnum * sizeof (rtx));
- map->const_equiv_map = (rtx *) alloca (maxregnum * sizeof (rtx));
- map->const_age_map = (unsigned *) alloca (maxregnum
- * sizeof (unsigned));
- map->const_equiv_map_size = maxregnum;
- global_const_equiv_map = map->const_equiv_map;
- global_const_equiv_map_size = maxregnum;
+ VARRAY_CONST_EQUIV_INIT (map->const_equiv_varray, maxregnum,
+ "unroll_loop");
+ global_const_equiv_varray = map->const_equiv_varray;
init_reg_map (map, maxregnum);
PREV_INSN (loop_start));
bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
- bzero ((char *) map->const_equiv_map, maxregnum * sizeof (rtx));
- bzero ((char *) map->const_age_map,
- maxregnum * sizeof (unsigned));
+ bzero ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
+ (VARRAY_SIZE (map->const_equiv_varray)
+ * sizeof (struct const_equiv_data)));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)
{
if (loop_dump_stream)
fprintf (loop_dump_stream, "Unrolling failure: Naive unrolling not being done.\n");
- return;
+ goto egress;
}
/* At this point, we are guaranteed to unroll the loop. */
init_reg_map (map, maxregnum);
- /* Space is needed in some of the map for new registers, so new_maxregnum
- is an (over)estimate of how many registers will exist at the end. */
- new_maxregnum = maxregnum + (temp * unroll_number * 2);
-
- /* Must realloc space for the constant maps, because the number of registers
- may have changed. */
-
- map->const_equiv_map = (rtx *) alloca (new_maxregnum * sizeof (rtx));
- map->const_age_map = (unsigned *) alloca (new_maxregnum * sizeof (unsigned));
-
- map->const_equiv_map_size = new_maxregnum;
- global_const_equiv_map = map->const_equiv_map;
- global_const_equiv_map_size = new_maxregnum;
+ if (map->const_equiv_varray == 0)
+ VARRAY_CONST_EQUIV_INIT (map->const_equiv_varray,
+ maxregnum + temp * unroll_number * 2,
+ "unroll_loop");
+ global_const_equiv_varray = map->const_equiv_varray;
/* Search the list of bivs and givs to find ones which need to be remapped
when split, and set their reg_map entry appropriately. */
for (i = 0; i < unroll_number; i++)
{
bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
- bzero ((char *) map->const_equiv_map, new_maxregnum * sizeof (rtx));
- bzero ((char *) map->const_age_map, new_maxregnum * sizeof (unsigned));
+ bzero ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
+ VARRAY_SIZE (map->const_equiv_varray) * sizeof (struct const_equiv_data));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)
not taken. */
if (exit_label)
emit_label_after (exit_label, loop_end);
+
+ egress:
+ if (map && map->const_equiv_varray)
+ VARRAY_FREE (map->const_equiv_varray);
}
\f
/* Return true if the loop can be safely, and profitably, preconditioned
{
int regno = REGNO (SET_DEST (pattern));
- if (regno < map->const_equiv_map_size
- && map->const_age_map[regno] == map->const_age)
- map->const_age_map[regno] = -1;
+ if (regno < VARRAY_SIZE (map->const_equiv_varray)
+ && (VARRAY_CONST_EQUIV (map->const_equiv_varray, regno).age
+ == map->const_age))
+ VARRAY_CONST_EQUIV (map->const_equiv_varray, regno).age = -1;
}
break;
/* Be lazy and assume CALL_INSNs clobber all hard registers. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- map->const_equiv_map[i] = 0;
+ VARRAY_CONST_EQUIV (map->const_equiv_varray, i).rtx = 0;
break;
case CODE_LABEL:
#include "system.h"
#endif
+/* Auxiliary structure used inside the varray structure, used for
+ function integration data. */
+
+struct const_equiv_data {
+ /* Map pseudo reg number in calling function to equivalent constant. We
+ cannot in general substitute constants into parameter pseudo registers,
+ since some machine descriptions (many RISCs) won't always handle
+ the resulting insns. So if an incoming parameter has a constant
+ equivalent, we record it here, and if the resulting insn is
+ recognizable, we go with it.
+
+ We also use this mechanism to convert references to incoming arguments
+ and stacked variables. copy_rtx_and_substitute will replace the virtual
+ incoming argument and virtual stacked variables registers with new
+ pseudos that contain pointers into the replacement area allocated for
+ this inline instance. These pseudos are then marked as being equivalent
+ to the appropriate address and substituted if valid. */
+ rtx rtx;
+
+ /* Record the valid age for each entry. The entry is invalid if its
+ age is less than const_age. */
+ unsigned age;
+};
+
/* Union of various array types that are used. */
typedef union varray_data_tag {
char c[1];
struct bitmap_head_def *bitmap[1];
struct sched_info_tag *sched[1];
struct reg_info_def *reg[1];
+ struct const_equiv_data const_equiv[1];
} varray_data;
/* Virtual array of pointers header. */
#define VARRAY_REG_INIT(va, num, name) \
va = varray_init (num, sizeof (struct reg_info_def *), name)
+#define VARRAY_CONST_EQUIV_INIT(va, num, name) \
+ va = varray_init (num, sizeof (struct const_equiv_data), name)
+
/* Free up memory allocated by the virtual array, but do not free any of the
elements involved. */
#define VARRAY_FREE(vp) \
#define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
+#define VARRAY_SIZE(VA) ((VA)->num_elements)
+
/* Check for VARRAY_xxx macros being in bound, return N for use as an
index. */
#ifdef ENABLE_CHECKING
#define VARRAY_BITMAP(VA, N) ((VA)->data.bitmap[ VARRAY_CHECK (VA, N) ])
#define VARRAY_SCHED(VA, N) ((VA)->data.sched[ VARRAY_CHECK (VA, N) ])
#define VARRAY_REG(VA, N) ((VA)->data.reg[ VARRAY_CHECK (VA, N) ])
+#define VARRAY_CONST_EQUIV(VA, N) ((VA)->data.const_equiv[ VARRAY_CHECK (VA, N) ])
#endif /* _VARRAY_H_ */
projects / thirdparty / gcc.git / commitdiff
