+Wed Oct 27 12:33:40 1999 Mark Mitchell <mark@codesourcery.com>
+
+ * rtl.h (note_stores): Add additional paramter.
+ * rtlanal.c (reg_set_p_1): Take additional paramter.
+ (reg_set_last_1): Likewise.
+ (reg_set_p): Adjust call to note_stores.
+ (reg_set_last): Likewise.
+ (note_stores): Pass data parameter to worker function.
+ * alias.c (record_set): Take additional parameter.
+ (init_alias_analysis): Pass it.
+ * caller-save.c (mark_set_regs): Take additional parameter.
+ (save_call_clobbered_regs): Pass NULL to note_stores.
+ * combine.c (set_nonzero_bits_and_sign_copies): Take additional
+ parameter.
+ (record_dead_and_set_regs_1): Likewise.
+ (reg_dead_at_p_1): Likewise.
+ (combine_instructions): Adjust calls to note_stores.
+ (try_combine): Likewise.
+ (record_dead_insn): Remove.
+ (record_dead_and_set_regs): Adjust calls to note_stores.
+ (reg_dead_at_p): Likewise.
+ * cse.c (invalidate_skipped_set): Take additional parameter.
+ (cse_check_loop_start): Likewise.
+ (cse_check_loop_start_value): Remove.
+ (cse_set_around_loop): Adjust calls to note_stores.
+ * flow.c (notice_stack_pointer_modification): Take additional
+ parameter. Remove duplicate declaration.
+ (record_volatile_insns): Adjust calls to note_stores.
+ * gcse.c (record_set_info): Take additional parameter.
+ (record_last_set_info): Likewise.
+ (invalidate_nonnull_info): Likewise.
+ (record_set_insn): Remove.
+ (compute_sets): Adjust calls to note_stores.
+ (last_set_insn): Remove.
+ (compute_hash_table): Adjust calls to note_stores.
+ (insert_insn_end_bb): Likewise.
+ (delete_null_pointer_checks): Likewise.
+ * global.c (mark_reg_store): Take additional parameter.
+ (mark_reg_clobber): Likewise.
+ (reg_becomes_live): Likewise.
+ (global_conflicts): Adjust calls to note_stores.
+ (build_insn_chain): Likewise.
+ * integrate.c (note_modified_parmregs): Take additional parameter.
+ (mark_stores): Likewise. Make it static.
+ (save_for_inline_nocopy): Adjust calls to note_stores.
+ (try_constants): Likewise.
+ * integrate.h (mark_stores): Remove declaration.
+ * jump.c (mark_modified_reg): Take additional parameter.
+ (thread_jumps): Adjust calls to note_stores.
+ * local-alloc.c (validate_equiv_mem_from_store): Take additional
+ parameter.
+ (no_equiv): Likewise.
+ (reg_is_set): Likewise.
+ (validate_equiv_mem): Adjust calls to note_stores.
+ (update_equiv_regs): Likewise.
+ (block_alloc): Likewise.
+ * loop.c (note_set_pseudo_multiple_uses_retval): Remove.
+ (note_addr_stored): Take additional parameter.
+ (note_set_pseudo_multiple_uses): Likewise.
+ (record_initial): Likewise.
+ (prescan_loop): Adjust calls to note_stores.
+ (strength_reduce): Likewise.
+ (check_dbra_loop): Likewise.
+ * regmove.c (flags_set_1): Take additional paramter.
+ (mark_flags_life_zones): Adjust calls to note_stores.
+ * reload1.c (mark_not_eliminable): Take additional parameter.
+ (forget_old_reloads_1): Likewise.
+ (reload_cse_invalidate_rtx): Likewise.
+ (reload_cse_check_clobber): Likewise.
+ (reload_combine_note_store): Likewise.
+ (move2add_note_store): Likewise.
+ (reload): Adjust calls to note_stores.
+ (reload_as_needed): Likewise.
+ (emit_reload_insns): Likewise.
+ (reload_cse_regs_1): Likewise.
+ (reload_cse_record_set): Adjust calls to reload_cse_invalidate_rtx.
+ (reload_combine): Adjust calls to note_stores.
+ * resource.c (update_live_status): Take additional paramter.
+ (mark_target_live_regs): Adjust calls to note_stores.
+ * stupid.c (find_clobbered_regs): Take additional parameter.
+ (stupid_life_analysis): Adjust calls to note_stores.
+
Wed Oct 27 19:26:12 1999 Nick Clifton <nickc@cygnus.com>
* config/arm/coff.h (STRUCTURE_SIZE_BOUNDARY): Delete
static rtx find_symbolic_term PROTO((rtx));
static int memrefs_conflict_p PROTO((int, rtx, int, rtx,
HOST_WIDE_INT));
-static void record_set PROTO((rtx, rtx));
+static void record_set PROTO((rtx, rtx, void *));
static rtx find_base_term PROTO((rtx));
static int base_alias_check PROTO((rtx, rtx, enum machine_mode,
enum machine_mode));
static int unique_id;
static void
-record_set (dest, set)
+record_set (dest, set, data)
rtx dest, set;
+ void *data ATTRIBUTE_UNUSED;
{
register unsigned regno;
rtx src;
if (GET_CODE (PATTERN (insn)) == SET
&& (find_reg_note (insn, REG_NOALIAS, NULL_RTX)))
- record_set (SET_DEST (PATTERN (insn)), NULL_RTX);
+ record_set (SET_DEST (PATTERN (insn)), NULL_RTX, NULL);
else
- note_stores (PATTERN (insn), record_set);
+ note_stores (PATTERN (insn), record_set, NULL);
set = single_set (insn);
static HARD_REG_SET this_insn_sets;
-static void mark_set_regs PROTO((rtx, rtx));
+static void mark_set_regs PROTO((rtx, rtx, void *));
static void mark_referenced_regs PROTO((rtx));
static int insert_save PROTO((struct insn_chain *, int, int,
HARD_REG_SET *));
/* Record all registers set in this call insn. These don't need
to be saved. */
CLEAR_HARD_REG_SET (this_insn_sets);
- note_stores (PATTERN (insn), mark_set_regs);
+ note_stores (PATTERN (insn), mark_set_regs, NULL);
/* Compute which hard regs must be saved before this call. */
AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
been assigned hard regs have had their register number changed already,
so we can ignore pseudos. */
static void
-mark_set_regs (reg, setter)
+mark_set_regs (reg, setter, data)
rtx reg;
rtx setter ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
register int regno, endregno, i;
enum machine_mode mode = GET_MODE (reg);
static void do_SUBST_INT PROTO((int *, int));
static void init_reg_last_arrays PROTO((void));
static void setup_incoming_promotions PROTO((void));
-static void set_nonzero_bits_and_sign_copies PROTO((rtx, rtx));
+static void set_nonzero_bits_and_sign_copies PROTO((rtx, rtx, void *));
static int can_combine_p PROTO((rtx, rtx, rtx, rtx, rtx *, rtx *));
static int sets_function_arg_p PROTO((rtx));
static int combinable_i3pat PROTO((rtx, rtx *, rtx, rtx, int, rtx *));
static int reversible_comparison_p PROTO((rtx));
static void update_table_tick PROTO((rtx));
static void record_value_for_reg PROTO((rtx, rtx, rtx));
-static void record_dead_and_set_regs_1 PROTO((rtx, rtx));
+static void record_dead_and_set_regs_1 PROTO((rtx, rtx, void *));
static void record_dead_and_set_regs PROTO((rtx));
static int get_last_value_validate PROTO((rtx *, rtx, int, int));
static rtx get_last_value PROTO((rtx));
static int use_crosses_set_p PROTO((rtx, int));
-static void reg_dead_at_p_1 PROTO((rtx, rtx));
+static void reg_dead_at_p_1 PROTO((rtx, rtx, void *));
static int reg_dead_at_p PROTO((rtx, rtx));
static void move_deaths PROTO((rtx, rtx, int, rtx, rtx *));
static int reg_bitfield_target_p PROTO((rtx, rtx));
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
{
- note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies);
+ note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies,
+ NULL);
record_dead_and_set_regs (insn);
#ifdef AUTO_INC_DEC
for (links = REG_NOTES (insn); links; links = XEXP (links, 1))
if (REG_NOTE_KIND (links) == REG_INC)
- set_nonzero_bits_and_sign_copies (XEXP (links, 0), NULL_RTX);
+ set_nonzero_bits_and_sign_copies (XEXP (links, 0), NULL_RTX,
+ NULL);
#endif
}
by any set of X. */
static void
-set_nonzero_bits_and_sign_copies (x, set)
+set_nonzero_bits_and_sign_copies (x, set, data)
rtx x;
rtx set;
+ void *data ATTRIBUTE_UNUSED;
{
int num;
/* Update reg_nonzero_bits et al for any changes that may have been made
to this insn. */
- note_stores (newpat, set_nonzero_bits_and_sign_copies);
+ note_stores (newpat, set_nonzero_bits_and_sign_copies, NULL);
if (newi2pat)
- note_stores (newi2pat, set_nonzero_bits_and_sign_copies);
+ note_stores (newi2pat, set_nonzero_bits_and_sign_copies, NULL);
/* If I3 is now an unconditional jump, ensure that it has a
BARRIER following it since it may have initially been a
}
}
-/* Used for communication between the following two routines. */
-static rtx record_dead_insn;
-
/* Called via note_stores from record_dead_and_set_regs to handle one
- SET or CLOBBER in an insn. */
+ SET or CLOBBER in an insn. DATA is the instruction in which the
+ set is occurring. */
static void
-record_dead_and_set_regs_1 (dest, setter)
+record_dead_and_set_regs_1 (dest, setter, data)
rtx dest, setter;
+ void *data;
{
+ rtx record_dead_insn = (rtx) data;
+
if (GET_CODE (dest) == SUBREG)
dest = SUBREG_REG (dest);
last_call_cuid = mem_last_set = INSN_CUID (insn);
}
- record_dead_insn = insn;
- note_stores (PATTERN (insn), record_dead_and_set_regs_1);
+ note_stores (PATTERN (insn), record_dead_and_set_regs_1, insn);
}
\f
/* Utility routine for the following function. Verify that all the registers
reg_dead_flag to 1 if X is a CLOBBER and to -1 it is a SET. */
static void
-reg_dead_at_p_1 (dest, x)
+reg_dead_at_p_1 (dest, x, data)
rtx dest;
rtx x;
+ void *data ATTRIBUTE_UNUSED;
{
int regno, endregno;
for (; insn && GET_CODE (insn) != CODE_LABEL && GET_CODE (insn) != BARRIER;
insn = prev_nonnote_insn (insn))
{
- note_stores (PATTERN (insn), reg_dead_at_p_1);
+ note_stores (PATTERN (insn), reg_dead_at_p_1, NULL);
if (reg_dead_flag)
return reg_dead_flag == 1 ? 1 : 0;
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));
+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));
+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));
since they are done elsewhere. This function is called via note_stores. */
static void
-invalidate_skipped_set (dest, set)
+invalidate_skipped_set (dest, set, data)
rtx set;
rtx dest;
+ void *data ATTRIBUTE_UNUSED;
{
enum rtx_code code = GET_CODE (dest);
}
invalidate_from_clobbers (PATTERN (insn));
- note_stores (PATTERN (insn), invalidate_skipped_set);
+ note_stores (PATTERN (insn), invalidate_skipped_set, NULL);
}
}
\f
-/* Used for communication between the following two routines; contains a
- value to be checked for modification. */
-
-static rtx cse_check_loop_start_value;
-
-/* If modifying X will modify the value in CSE_CHECK_LOOP_START_VALUE,
- indicate that fact by setting CSE_CHECK_LOOP_START_VALUE to 0. */
+/* If modifying X will modify the value in *DATA (which is really an
+ `rtx *'), indicate that fact by setting the pointed to value to
+ NULL_RTX. */
static void
-cse_check_loop_start (x, set)
+cse_check_loop_start (x, set, data)
rtx x;
rtx set ATTRIBUTE_UNUSED;
+ void *data;
{
- if (cse_check_loop_start_value == 0
+ rtx *cse_check_loop_start_value = (rtx *) data;
+
+ if (*cse_check_loop_start_value == NULL_RTX
|| GET_CODE (x) == CC0 || GET_CODE (x) == PC)
return;
- if ((GET_CODE (x) == MEM && GET_CODE (cse_check_loop_start_value) == MEM)
- || reg_overlap_mentioned_p (x, cse_check_loop_start_value))
- cse_check_loop_start_value = 0;
+ if ((GET_CODE (x) == MEM && GET_CODE (*cse_check_loop_start_value) == MEM)
+ || reg_overlap_mentioned_p (x, *cse_check_loop_start_value))
+ *cse_check_loop_start_value = NULL_RTX;
}
/* X is a SET or CLOBBER contained in INSN that was found near the start of
can modify it, or we would have invalidated it in
the hash table. */
rtx q;
-
- cse_check_loop_start_value = SET_SRC (x);
+ rtx cse_check_loop_start_value = SET_SRC (x);
for (q = p; q != loop_start; q = NEXT_INSN (q))
if (GET_RTX_CLASS (GET_CODE (q)) == 'i')
- note_stores (PATTERN (q), cse_check_loop_start);
+ note_stores (PATTERN (q),
+ cse_check_loop_start,
+ &cse_check_loop_start_value);
/* If nothing was changed and we can replace our
SET_SRC, add an insn after P to copy its destination
static void verify_local_live_at_start PROTO((regset, basic_block));
static int set_noop_p PROTO((rtx));
static int noop_move_p PROTO((rtx));
-static void notice_stack_pointer_modification PROTO ((rtx, rtx));
+static void notice_stack_pointer_modification PROTO ((rtx, rtx, void *));
static void record_volatile_insns PROTO((rtx));
static void mark_reg PROTO((regset, rtx));
static void mark_regs_live_at_end PROTO((regset));
static void count_reg_sets_1 PROTO ((rtx));
static void count_reg_sets PROTO ((rtx));
static void count_reg_references PROTO ((rtx));
-static void notice_stack_pointer_modification PROTO ((rtx, rtx));
static void invalidate_mems_from_autoinc PROTO ((rtx));
static void remove_edge PROTO ((edge));
static void remove_fake_successors PROTO ((basic_block));
}
static void
-notice_stack_pointer_modification (x, pat)
+notice_stack_pointer_modification (x, pat, data)
rtx x;
rtx pat ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
if (x == stack_pointer_rtx
/* The stack pointer is only modified indirectly as the result
/* Check if insn modifies the stack pointer. */
if ( current_function_sp_is_unchanging
&& GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- note_stores (PATTERN (insn), notice_stack_pointer_modification);
+ note_stores (PATTERN (insn),
+ notice_stack_pointer_modification,
+ NULL);
}
}
static void alloc_reg_set_mem PROTO ((int));
static void free_reg_set_mem PROTO ((void));
static void record_one_set PROTO ((int, rtx));
-static void record_set_info PROTO ((rtx, rtx));
+static void record_set_info PROTO ((rtx, rtx, void *));
static void compute_sets PROTO ((rtx));
static void hash_scan_insn PROTO ((rtx, int, int));
static int expr_equiv_p PROTO ((rtx, rtx));
static void record_last_reg_set_info PROTO ((rtx, int));
static void record_last_mem_set_info PROTO ((rtx));
-static void record_last_set_info PROTO ((rtx, rtx));
+static void record_last_set_info PROTO ((rtx, rtx, void *));
static void compute_hash_table PROTO ((int));
static void alloc_set_hash_table PROTO ((int));
static void free_set_hash_table PROTO ((void));
static int handle_avail_expr PROTO ((rtx, struct expr *));
static int classic_gcse PROTO ((void));
static int one_classic_gcse_pass PROTO ((int));
-static void invalidate_nonnull_info PROTO ((rtx, rtx));
+static void invalidate_nonnull_info PROTO ((rtx, rtx, void *));
static rtx process_insert_insn PROTO ((struct expr *));
static int pre_edge_insert PROTO ((struct edge_list *, struct expr **));
\f
}
}
-/* For communication between next two functions (via note_stores). */
-static rtx record_set_insn;
-
/* Called from compute_sets via note_stores to handle one
- SET or CLOBBER in an insn. */
+ SET or CLOBBER in an insn. The DATA is really the instruction
+ in which the SET is occurring. */
static void
-record_set_info (dest, setter)
+record_set_info (dest, setter, data)
rtx dest, setter ATTRIBUTE_UNUSED;
+ void *data;
{
+ rtx record_set_insn = (rtx) data;
+
if (GET_CODE (dest) == SUBREG)
dest = SUBREG_REG (dest);
while (insn)
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- {
- record_set_insn = insn;
- note_stores (PATTERN (insn), record_set_info);
- }
+ note_stores (PATTERN (insn), record_set_info, insn);
insn = NEXT_INSN (insn);
}
}
mem_set_in_block[BLOCK_NUM (insn)] = 1;
}
-/* Used for communicating between next two routines. */
-static rtx last_set_insn;
-
/* Called from compute_hash_table via note_stores to handle one
- SET or CLOBBER in an insn. */
+ SET or CLOBBER in an insn. DATA is really the instruction in which
+ the SET is taking place. */
static void
-record_last_set_info (dest, setter)
+record_last_set_info (dest, setter, data)
rtx dest, setter ATTRIBUTE_UNUSED;
+ void *data;
{
+ rtx last_set_insn = (rtx) data;
+
if (GET_CODE (dest) == SUBREG)
dest = SUBREG_REG (dest);
record_last_mem_set_info (insn);
}
- last_set_insn = insn;
- note_stores (PATTERN (insn), record_last_set_info);
+ note_stores (PATTERN (insn), record_last_set_info, insn);
}
/* The next pass builds the hash table. */
set_block_num (insn, bb);
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
add_label_notes (PATTERN (insn), new_insn);
- record_set_insn = insn;
- note_stores (PATTERN (insn), record_set_info);
+ note_stores (PATTERN (insn), record_set_info, insn);
}
}
else
We ignore hard registers. */
static void
-invalidate_nonnull_info (x, setter)
+invalidate_nonnull_info (x, setter, data)
rtx x;
rtx setter ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
int offset, regno;
set = single_set (insn);
if (!set)
{
- note_stores (PATTERN (insn), invalidate_nonnull_info);
+ note_stores (PATTERN (insn), invalidate_nonnull_info, NULL);
continue;
}
REGNO (XEXP (SET_SRC (set), 0)));
/* Now invalidate stuff clobbered by this insn. */
- note_stores (PATTERN (insn), invalidate_nonnull_info);
+ note_stores (PATTERN (insn), invalidate_nonnull_info, NULL);
/* And handle stores, we do these last since any sets in INSN can
not kill the nonnull property if it is derived from a MEM
static void find_reg PROTO((int, HARD_REG_SET, int, int, int));
static void record_one_conflict PROTO((int));
static void record_conflicts PROTO((int *, int));
-static void mark_reg_store PROTO((rtx, rtx));
-static void mark_reg_clobber PROTO((rtx, rtx));
+static void mark_reg_store PROTO((rtx, rtx, void *));
+static void mark_reg_clobber PROTO((rtx, rtx, void *));
static void mark_reg_conflicts PROTO((rtx));
static void mark_reg_death PROTO((rtx));
static void mark_reg_live_nc PROTO((int, enum machine_mode));
static void set_preference PROTO((rtx, rtx));
static void dump_conflicts PROTO((FILE *));
-static void reg_becomes_live PROTO((rtx, rtx));
+static void reg_becomes_live PROTO((rtx, rtx, void *));
static void reg_dies PROTO((int, enum machine_mode));
static void build_insn_chain PROTO((rtx));
\f
/* Mark any registers clobbered by INSN as live,
so they conflict with the inputs. */
- note_stores (PATTERN (insn), mark_reg_clobber);
+ note_stores (PATTERN (insn), mark_reg_clobber, NULL);
/* Mark any registers dead after INSN as dead now. */
Clobbers are processed again, so they conflict with
the registers that are set. */
- note_stores (PATTERN (insn), mark_reg_store);
+ note_stores (PATTERN (insn), mark_reg_store, NULL);
#ifdef AUTO_INC_DEC
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
if (REG_NOTE_KIND (link) == REG_INC)
- mark_reg_store (XEXP (link, 0), NULL_RTX);
+ mark_reg_store (XEXP (link, 0), NULL_RTX, NULL);
#endif
/* If INSN has multiple outputs, then any reg that dies here
a REG_INC note was found for it). */
static void
-mark_reg_store (reg, setter)
+mark_reg_store (reg, setter, data)
rtx reg, setter;
+ void *data ATTRIBUTE_UNUSED;
{
register int regno;
/* Like mark_reg_set except notice just CLOBBERs; ignore SETs. */
static void
-mark_reg_clobber (reg, setter)
+mark_reg_clobber (reg, setter, data)
rtx reg, setter;
+ void *data ATTRIBUTE_UNUSED;
{
if (GET_CODE (setter) == CLOBBER)
- mark_reg_store (reg, setter);
+ mark_reg_store (reg, setter, data);
}
/* Record that REG has conflicts with all the regs currently live.
/* Record in live_relevant_regs that register REG became live. This
is called via note_stores. */
static void
-reg_becomes_live (reg, setter)
+reg_becomes_live (reg, setter, data)
rtx reg;
rtx setter ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
int regno;
/* Mark everything born in this instruction as live. */
- note_stores (PATTERN (first), reg_becomes_live);
+ note_stores (PATTERN (first), reg_becomes_live, NULL);
}
/* Remember which registers are live at the end of the insn, before
#endif
\f
static rtvec initialize_for_inline PROTO((tree));
-static void note_modified_parmregs PROTO((rtx, rtx));
+static void note_modified_parmregs PROTO((rtx, rtx, void *));
static void integrate_parm_decls PROTO((tree, struct inline_remap *,
rtvec));
static tree integrate_decl_tree PROTO((tree,
void set_decl_abstract_flags PROTO((tree, int));
static tree copy_and_set_decl_abstract_origin PROTO((tree));
static rtx expand_inline_function_eh_labelmap PROTO((rtx));
+static void mark_stores PROTO((rtx, rtx, void *));
/* The maximum number of instructions accepted for inlining a
function. Increasing values mean more agressive inlining.
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
/* Record what interesting things happen to our parameters. */
- note_stores (PATTERN (insn), note_modified_parmregs);
+ note_stores (PATTERN (insn), note_modified_parmregs, NULL);
}
/* We have now allocated all that needs to be allocated permanently
/* Note whether a parameter is modified or not. */
static void
-note_modified_parmregs (reg, x)
+note_modified_parmregs (reg, x, data)
rtx reg;
rtx x ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
if (GET_CODE (reg) == REG && in_nonparm_insns
&& REGNO (reg) < max_parm_reg
apply_change_group ();
/* Show we don't know the value of anything stored or clobbered. */
- note_stores (PATTERN (insn), mark_stores);
+ note_stores (PATTERN (insn), mark_stores, NULL);
map->last_pc_value = 0;
#ifdef HAVE_cc0
map->last_cc0_value = 0;
called from note_stores with parts of the new insn. */
void
-mark_stores (dest, x)
+mark_stores (dest, x, data)
rtx dest;
rtx x ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
int regno = -1;
enum machine_mode mode = VOIDmode;
extern void try_constants PROTO((rtx, struct inline_remap *));
-extern void mark_stores PROTO((rtx, rtx));
-
/* Return the label indicated. */
extern rtx get_label_from_map PROTO((struct inline_remap *, int));
static void delete_computation PROTO((rtx));
static void delete_from_jump_chain PROTO((rtx));
static int delete_labelref_insn PROTO((rtx, rtx, int));
-static void mark_modified_reg PROTO((rtx, rtx));
+static void mark_modified_reg PROTO((rtx, rtx, void *));
static void redirect_tablejump PROTO((rtx, rtx));
static void jump_optimize_1 PROTO ((rtx, int, int, int, int));
#if ! defined(HAVE_cc0) && ! defined(HAVE_conditional_arithmetic)
branch and the second branch. It marks any changed registers. */
static void
-mark_modified_reg (dest, x)
+mark_modified_reg (dest, x, data)
rtx dest;
rtx x ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
int regno, i;
modified_regs[i] = 1;
}
- note_stores (PATTERN (b2), mark_modified_reg);
+ note_stores (PATTERN (b2), mark_modified_reg, NULL);
}
/* Check the next candidate branch insn from the label
static int recorded_label_ref;
static void alloc_qty PROTO((int, enum machine_mode, int, int));
-static void validate_equiv_mem_from_store PROTO((rtx, rtx));
+static void validate_equiv_mem_from_store PROTO((rtx, rtx, void *));
static int validate_equiv_mem PROTO((rtx, rtx, rtx));
static int contains_replace_regs PROTO((rtx, char *));
static int memref_referenced_p PROTO((rtx, rtx));
static int memref_used_between_p PROTO((rtx, rtx, rtx));
static void update_equiv_regs PROTO((void));
-static void no_equiv PROTO((rtx, rtx));
+static void no_equiv PROTO((rtx, rtx, void *));
static void block_alloc PROTO((int));
static int qty_sugg_compare PROTO((int, int));
static int qty_sugg_compare_1 PROTO((const PTR, const PTR));
static int combine_regs PROTO((rtx, rtx, int, int, rtx, int));
static int reg_meets_class_p PROTO((int, enum reg_class));
static void update_qty_class PROTO((int, int));
-static void reg_is_set PROTO((rtx, rtx));
+static void reg_is_set PROTO((rtx, rtx, void *));
static void reg_is_born PROTO((rtx, int));
static void wipe_dead_reg PROTO((rtx, int));
static int find_free_reg PROTO((enum reg_class, enum machine_mode,
Called via note_stores. */
static void
-validate_equiv_mem_from_store (dest, set)
+validate_equiv_mem_from_store (dest, set, data)
rtx dest;
rtx set ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
if ((GET_CODE (dest) == REG
&& reg_overlap_mentioned_p (dest, equiv_mem))
&& ! CONST_CALL_P (insn))
return 0;
- note_stores (PATTERN (insn), validate_equiv_mem_from_store);
+ note_stores (PATTERN (insn), validate_equiv_mem_from_store, NULL);
/* If a register mentioned in MEMREF is modified via an
auto-increment, we lose the equivalence. Do the same if one
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
if (REG_NOTE_KIND (note) == REG_INC)
- no_equiv (XEXP (note, 0), note);
+ no_equiv (XEXP (note, 0), note, NULL);
set = single_set (insn);
only mark all destinations as having no known equivalence. */
if (set == 0)
{
- note_stores (PATTERN (insn), no_equiv);
+ note_stores (PATTERN (insn), no_equiv, NULL);
continue;
}
else if (GET_CODE (PATTERN (insn)) == PARALLEL)
{
rtx part = XVECEXP (PATTERN (insn), 0, i);
if (part != set)
- note_stores (part, no_equiv);
+ note_stores (part, no_equiv, NULL);
}
}
{
/* This might be seting a SUBREG of a pseudo, a pseudo that is
also set somewhere else to a constant. */
- note_stores (set, no_equiv);
+ note_stores (set, no_equiv, NULL);
continue;
}
/* Don't handle the equivalence if the source is in a register
&& REGNO (src) >= FIRST_PSEUDO_REGISTER
&& CLASS_LIKELY_SPILLED_P (reg_preferred_class (REGNO (src))))
{
- no_equiv (dest, set);
+ no_equiv (dest, set, NULL);
continue;
}
&& ! rtx_equal_p (XEXP (note, 0),
reg_equiv_replacement[regno]))))
{
- no_equiv (dest, set);
+ no_equiv (dest, set, NULL);
continue;
}
/* Record this insn as initializing this register. */
assignment - a SET, CLOBBER or REG_INC note. It is currently not used,
but needs to be there because this function is called from note_stores. */
static void
-no_equiv (reg, store)
+no_equiv (reg, store, data)
rtx reg, store ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
int regno;
rtx list;
that are born (set) in this instruction.
A pseudo that already has a qty is not changed. */
- note_stores (PATTERN (insn), reg_is_set);
+ note_stores (PATTERN (insn), reg_is_set, NULL);
/* If anything is set in this insn and then unused, mark it as dying
after this insn, so it will conflict with our outputs. This
carry info from `block_alloc'. */
static void
-reg_is_set (reg, setter)
+reg_is_set (reg, setter, data)
rtx reg;
rtx setter;
+ void *data ATTRIBUTE_UNUSED;
{
/* Note that note_stores will only pass us a SUBREG if it is a SUBREG of
a hard register. These may actually not exist any more. */
FILE *loop_dump_stream;
-/* For communicating return values from note_set_pseudo_multiple_uses. */
-static int note_set_pseudo_multiple_uses_retval;
-
/* Forward declarations. */
static void verify_dominator PROTO((int));
static void count_loop_regs_set PROTO((rtx, rtx, varray_type, varray_type,
int *, int));
-static void note_addr_stored PROTO((rtx, rtx));
-static void note_set_pseudo_multiple_uses PROTO((rtx, rtx));
+static void note_addr_stored PROTO((rtx, rtx, void *));
+static void note_set_pseudo_multiple_uses PROTO((rtx, rtx, void *));
static int loop_reg_used_before_p PROTO((rtx, rtx, rtx, rtx, rtx));
static void scan_loop PROTO((rtx, rtx, rtx, int, int));
#if 0
static int maybe_eliminate_biv PROTO((struct iv_class *, rtx, rtx, int, int, int));
static int maybe_eliminate_biv_1 PROTO((rtx, rtx, struct iv_class *, int, rtx));
static int last_use_this_basic_block PROTO((rtx, rtx));
-static void record_initial PROTO((rtx, rtx));
+static void record_initial PROTO((rtx, rtx, void *));
static void update_reg_last_use PROTO((rtx, rtx));
static rtx next_insn_in_loop PROTO((rtx, rtx, rtx, rtx));
static void load_mems_and_recount_loop_regs_set PROTO((rtx, rtx, rtx,
|| GET_CODE (PATTERN (insn)) == ADDR_VEC))
loop_info->has_tablejump = 1;
- note_stores (PATTERN (insn), note_addr_stored);
+ note_stores (PATTERN (insn), note_addr_stored, NULL);
if (! first_loop_store_insn && loop_store_mems)
first_loop_store_insn = insn;
/* Record that a memory reference X is being set. */
static void
-note_addr_stored (x, y)
+note_addr_stored (x, y, data)
rtx x;
rtx y ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
if (x == 0 || GET_CODE (x) != MEM)
return;
/* X is a value modified by an INSN that references a biv inside a loop
exit test (ie, X is somehow related to the value of the biv). If X
is a pseudo that is used more than once, then the biv is (effectively)
- used more than once. */
+ used more than once. DATA is really an `int *', and is set if the
+ biv is used more than once. */
static void
-note_set_pseudo_multiple_uses (x, y)
+note_set_pseudo_multiple_uses (x, y, data)
rtx x;
rtx y ATTRIBUTE_UNUSED;
+ void *data;
{
if (x == 0)
return;
if (REGNO (x) >= max_reg_before_loop
|| ! VARRAY_RTX (reg_single_usage, REGNO (x))
|| VARRAY_RTX (reg_single_usage, REGNO (x)) == const0_rtx)
- note_set_pseudo_multiple_uses_retval = 1;
+ *((int *) data) = 1;
}
\f
/* Return nonzero if the rtx X is invariant over the current loop.
if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
|| GET_CODE (p) == CALL_INSN)
- note_stores (PATTERN (p), record_initial);
+ note_stores (PATTERN (p), record_initial, NULL);
/* Record any test of a biv that branches around the loop if no store
between it and the start of loop. We only care about tests with
that has more than one usage, then the biv has uses
other than counting since it's used to derive a value
that is used more than one time. */
- note_set_pseudo_multiple_uses_retval = 0;
- note_stores (PATTERN (p), note_set_pseudo_multiple_uses);
+ int note_set_pseudo_multiple_uses_retval = 0;
+ note_stores (PATTERN (p), note_set_pseudo_multiple_uses,
+ ¬e_set_pseudo_multiple_uses_retval);
if (note_set_pseudo_multiple_uses_retval)
{
no_use_except_counting = 0;
just record the location of the set and process it later. */
static void
-record_initial (dest, set)
+record_initial (dest, set, data)
rtx dest;
rtx set;
+ void *data ATTRIBUTE_UNUSED;
{
struct iv_class *bl;
static rtx discover_flags_reg PROTO((void));
static void mark_flags_life_zones PROTO((rtx));
-static void flags_set_1 PROTO((rtx, rtx));
+static void flags_set_1 PROTO((rtx, rtx, void *));
static int try_auto_increment PROTO((rtx, rtx, rtx, rtx, HOST_WIDE_INT, int));
static int find_matches PROTO((rtx, struct match *));
/* In either case, birth is denoted simply by it's presence
as the destination of a set. */
flags_set_1_set = 0;
- note_stores (PATTERN (insn), flags_set_1);
+ note_stores (PATTERN (insn), flags_set_1, NULL);
if (flags_set_1_set)
{
live = 1;
/* A subroutine of mark_flags_life_zones, called through note_stores. */
static void
-flags_set_1 (x, pat)
+flags_set_1 (x, pat, data)
rtx x, pat;
+ void *data ATTRIBUTE_UNUSED;
{
if (GET_CODE (pat) == SET
&& reg_overlap_mentioned_p (x, flags_set_1_rtx))
static void elimination_effects PROTO((rtx, enum machine_mode));
static int eliminate_regs_in_insn PROTO((rtx, int));
static void update_eliminable_offsets PROTO((void));
-static void mark_not_eliminable PROTO((rtx, rtx));
+static void mark_not_eliminable PROTO((rtx, rtx, void *));
static void set_initial_elim_offsets PROTO((void));
static void verify_initial_elim_offsets PROTO((void));
static void set_initial_label_offsets PROTO((void));
static void count_pseudo PROTO((struct hard_reg_n_uses *, int));
static void order_regs_for_reload PROTO((struct insn_chain *));
static void reload_as_needed PROTO((int));
-static void forget_old_reloads_1 PROTO((rtx, rtx));
+static void forget_old_reloads_1 PROTO((rtx, rtx, void *));
static int reload_reg_class_lower PROTO((const PTR, const PTR));
static void mark_reload_reg_in_use PROTO((int, int, enum reload_type,
enum machine_mode));
static void reload_cse_invalidate_regno PROTO((int, enum machine_mode, int));
static int reload_cse_mem_conflict_p PROTO((rtx, rtx));
static void reload_cse_invalidate_mem PROTO((rtx));
-static void reload_cse_invalidate_rtx PROTO((rtx, rtx));
+static void reload_cse_invalidate_rtx PROTO((rtx, rtx, void *));
static int reload_cse_regno_equal_p PROTO((int, rtx, enum machine_mode));
static int reload_cse_noop_set_p PROTO((rtx, rtx));
static int reload_cse_simplify_set PROTO((rtx, rtx));
static int reload_cse_simplify_operands PROTO((rtx));
-static void reload_cse_check_clobber PROTO((rtx, rtx));
+static void reload_cse_check_clobber PROTO((rtx, rtx, void *));
static void reload_cse_record_set PROTO((rtx, rtx));
static void reload_combine PROTO((void));
static void reload_combine_note_use PROTO((rtx *, rtx));
-static void reload_combine_note_store PROTO((rtx, rtx));
+static void reload_combine_note_store PROTO((rtx, rtx, void *));
static void reload_cse_move2add PROTO((rtx));
-static void move2add_note_store PROTO((rtx, rtx));
+static void move2add_note_store PROTO((rtx, rtx, void *));
#ifdef AUTO_INC_DEC
static void add_auto_inc_notes PROTO((rtx, rtx));
#endif
for (insn = first; insn && num_eliminable; insn = NEXT_INSN (insn))
if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
|| GET_CODE (insn) == CALL_INSN)
- note_stores (PATTERN (insn), mark_not_eliminable);
+ note_stores (PATTERN (insn), mark_not_eliminable, NULL);
maybe_fix_stack_asms ();
the insns of the function. */
static void
-mark_not_eliminable (dest, x)
+mark_not_eliminable (dest, x, data)
rtx dest;
rtx x;
+ void *data ATTRIBUTE_UNUSED;
{
register unsigned int i;
for this insn in order to be stored in
(obeying register constraints). That is correct; such reload
registers ARE still valid. */
- note_stores (oldpat, forget_old_reloads_1);
+ note_stores (oldpat, forget_old_reloads_1, NULL);
/* There may have been CLOBBER insns placed after INSN. So scan
between INSN and NEXT and use them to forget old reloads. */
for (x = NEXT_INSN (insn); x != old_next; x = NEXT_INSN (x))
if (GET_CODE (x) == INSN && GET_CODE (PATTERN (x)) == CLOBBER)
- note_stores (PATTERN (x), forget_old_reloads_1);
+ note_stores (PATTERN (x), forget_old_reloads_1, NULL);
#ifdef AUTO_INC_DEC
/* Likewise for regs altered by auto-increment in this insn.
reg_has_output_reload[REGNO (XEXP (in_reg, 0))] = 1;
}
else
- forget_old_reloads_1 (XEXP (in_reg, 0), NULL_RTX);
+ forget_old_reloads_1 (XEXP (in_reg, 0), NULL_RTX,
+ NULL);
}
else if ((code == PRE_INC || code == PRE_DEC)
&& TEST_HARD_REG_BIT (reg_reloaded_valid,
break;
if (i == n_reloads)
- forget_old_reloads_1 (XEXP (x, 0), NULL_RTX);
+ forget_old_reloads_1 (XEXP (x, 0), NULL_RTX, NULL);
}
#endif
}
or it may be a pseudo reg that was reloaded from. */
static void
-forget_old_reloads_1 (x, ignored)
+forget_old_reloads_1 (x, ignored, data)
rtx x;
rtx ignored ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
register int regno;
int nr;
clear any memory of reloaded copies of the pseudo reg.
If this output reload comes from a spill reg,
reg_has_output_reload will make this do nothing. */
- note_stores (pat, forget_old_reloads_1);
+ note_stores (pat, forget_old_reloads_1, NULL);
if (reg_mentioned_p (rld[j].reg_rtx, pat))
{
note_stores; it is ignored. */
static void
-reload_cse_invalidate_rtx (dest, ignore)
+reload_cse_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
if (GET_CODE (x) == SET)
reload_cse_record_set (x, body);
else
- note_stores (x, reload_cse_invalidate_rtx);
+ note_stores (x, reload_cse_invalidate_rtx, NULL);
}
}
else
- note_stores (body, reload_cse_invalidate_rtx);
+ note_stores (body, reload_cse_invalidate_rtx, NULL);
#ifdef AUTO_INC_DEC
/* Clobber any registers which appear in REG_INC notes. We
for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
if (REG_NOTE_KIND (x) == REG_INC)
- reload_cse_invalidate_rtx (XEXP (x, 0), NULL_RTX);
+ reload_cse_invalidate_rtx (XEXP (x, 0), NULL_RTX, NULL);
}
#endif
for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
if (GET_CODE (XEXP (x, 0)) == CLOBBER)
- reload_cse_invalidate_rtx (XEXP (XEXP (x, 0), 0), NULL_RTX);
+ reload_cse_invalidate_rtx (XEXP (XEXP (x, 0), 0), NULL_RTX,
+ NULL);
}
}
second argument, which is passed by note_stores, is ignored. */
static void
-reload_cse_check_clobber (dest, ignore)
+reload_cse_check_clobber (dest, ignore, data)
rtx dest;
rtx ignore ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
if (reg_overlap_mentioned_p (dest, reload_cse_check_src))
reload_cse_check_clobbered = 1;
x = XEXP (x, 0);
if (push_operand (x, GET_MODE (x)))
{
- reload_cse_invalidate_rtx (stack_pointer_rtx, NULL_RTX);
- reload_cse_invalidate_rtx (dest, NULL_RTX);
+ reload_cse_invalidate_rtx (stack_pointer_rtx, NULL_RTX, NULL);
+ reload_cse_invalidate_rtx (dest, NULL_RTX, NULL);
return;
}
|| side_effects_p (src)
|| side_effects_p (dest))
{
- reload_cse_invalidate_rtx (dest, NULL_RTX);
+ reload_cse_invalidate_rtx (dest, NULL_RTX, NULL);
return;
}
if (reg_mentioned_p (cc0_rtx, src)
|| reg_mentioned_p (cc0_rtx, dest))
{
- reload_cse_invalidate_rtx (dest, NULL_RTX);
+ reload_cse_invalidate_rtx (dest, NULL_RTX, NULL);
return;
}
#endif
reload_cse_check_clobbered = 0;
reload_cse_check_src = src;
- note_stores (x, reload_cse_check_clobber);
+ note_stores (x, reload_cse_check_clobber, NULL);
if (reload_cse_check_clobbered)
{
- reload_cse_invalidate_rtx (dest, NULL_RTX);
+ reload_cse_invalidate_rtx (dest, NULL_RTX, NULL);
return;
}
}
}
}
}
- note_stores (PATTERN (insn), reload_combine_note_store);
+ note_stores (PATTERN (insn), reload_combine_note_store, NULL);
if (GET_CODE (insn) == CALL_INSN)
{
rtx link;
update reg_state[regno].store_ruid and reg_state[regno].use_index
accordingly. Called via note_stores from reload_combine. */
static void
-reload_combine_note_store (dst, set)
+reload_combine_note_store (dst, set, data)
rtx dst, set;
+ void *data ATTRIBUTE_UNUSED;
{
int regno = 0;
int i;
}
}
}
- note_stores (PATTERN (insn), move2add_note_store);
+ note_stores (PATTERN (insn), move2add_note_store, NULL);
/* If this is a CALL_INSN, all call used registers are stored with
unknown values. */
if (GET_CODE (insn) == CALL_INSN)
Update reg_set_luid, reg_offset and reg_base_reg accordingly.
Called from reload_cse_move2add via note_stores. */
static void
-move2add_note_store (dst, set)
+move2add_note_store (dst, set, data)
rtx dst, set;
+ void *data ATTRIBUTE_UNUSED;
{
int regno = 0;
int i;
static HARD_REG_SET pending_dead_regs;
\f
-static void update_live_status PROTO ((rtx, rtx));
+static void update_live_status PROTO ((rtx, rtx, void *));
static rtx next_insn_no_annul PROTO ((rtx));
static rtx find_dead_or_set_registers PROTO ((rtx, struct resources*,
rtx*, int, struct resources,
It deadens any CLOBBERed registers and livens any SET registers. */
static void
-update_live_status (dest, x)
+update_live_status (dest, x, data)
rtx dest;
rtx x;
+ void *data ATTRIBUTE_UNUSED;
{
int first_regno, last_regno;
int i;
SET_HARD_REG_BIT (pending_dead_regs, i);
}
- note_stores (PATTERN (real_insn), update_live_status);
+ note_stores (PATTERN (real_insn), update_live_status, NULL);
/* If any registers were unused after this insn, kill them.
These notes will always be accurate. */
extern rtx find_last_value PROTO((rtx, rtx *, rtx, int));
extern int refers_to_regno_p PROTO((int, int, rtx, rtx *));
extern int reg_overlap_mentioned_p PROTO((rtx, rtx));
-extern void note_stores PROTO((rtx, void (*)(rtx, rtx)));
+extern void note_stores PROTO((rtx, void (*)(rtx, rtx, void *), void *));
extern rtx reg_set_last PROTO((rtx, rtx));
extern int rtx_equal_p PROTO((rtx, rtx));
extern int dead_or_set_p PROTO((rtx, rtx));
#include "rtl.h"
static int rtx_addr_can_trap_p PROTO((rtx));
-static void reg_set_p_1 PROTO((rtx, rtx));
-static void reg_set_last_1 PROTO((rtx, rtx));
+static void reg_set_p_1 PROTO((rtx, rtx, void *));
+static void reg_set_last_1 PROTO((rtx, rtx, void *));
/* Forward declarations */
static int reg_set_flag;
static void
-reg_set_p_1 (x, pat)
+reg_set_p_1 (x, pat, data)
rtx x;
rtx pat ATTRIBUTE_UNUSED;
+ void *data ATTRIBUTE_UNUSED;
{
/* We don't want to return 1 if X is a MEM that contains a register
within REG_SET_REG. */
reg_set_reg = reg;
reg_set_flag = 0;
- note_stores (body, reg_set_p_1);
+ note_stores (body, reg_set_p_1, NULL);
return reg_set_flag;
}
/* Called via note_stores from reg_set_last. */
static void
-reg_set_last_1 (x, pat)
+reg_set_last_1 (x, pat, data)
rtx x;
rtx pat;
+ void *data ATTRIBUTE_UNUSED;
{
int first, last;
insn = PREV_INSN (insn))
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
{
- note_stores (PATTERN (insn), reg_set_last_1);
+ note_stores (PATTERN (insn), reg_set_last_1, NULL);
if (reg_set_last_unknown)
return 0;
else if (reg_set_last_value)
the SUBREG will be passed. */
void
-note_stores (x, fun)
+note_stores (x, fun, data)
register rtx x;
- void (*fun) PROTO ((rtx, rtx));
+ void (*fun) PROTO ((rtx, rtx, void *));
+ void *data;
{
if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER))
{
{
register int i;
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
- (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x);
+ (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x, data);
}
else
- (*fun) (dest, x);
+ (*fun) (dest, x, data);
}
else if (GET_CODE (x) == PARALLEL)
{
{
register int i;
for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
- (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y);
+ (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y, data);
}
else
- (*fun) (dest, y);
+ (*fun) (dest, y, data);
}
}
}
static int stupid_find_reg PROTO((int, enum reg_class, enum machine_mode,
int, int, int));
static void stupid_mark_refs PROTO((rtx, struct insn_chain *));
-static void find_clobbered_regs PROTO((rtx, rtx));
+static void find_clobbered_regs PROTO((rtx, rtx, void *));
\f
/* For communication between stupid_life_analysis and find_clobbered_regs. */
static struct insn_chain *current_chain;
of the appropriate insn_chain structure. */
static void
-find_clobbered_regs (reg, setter)
+find_clobbered_regs (reg, setter, data)
rtx reg, setter;
+ void *data ATTRIBUTE_UNUSED;
{
int regno, nregs;
if (setter == 0 || GET_CODE (setter) != CLOBBER)
pattern. */
current_chain = chain;
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- note_stores (PATTERN (insn), find_clobbered_regs);
+ note_stores (PATTERN (insn), find_clobbered_regs, NULL);
}
if (GET_CODE (insn) == JUMP_INSN && computed_jump_p (insn))
projects / platform / upstream / linaro-gcc.git / commitdiff