/* Standard problems for dataflow support routines.
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009, 2010 Free Software Foundation, Inc.
+ 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
Originally contributed by Michael P. Hayes
(m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
#include "basic-block.h"
#include "sbitmap.h"
#include "bitmap.h"
+#include "target.h"
#include "timevar.h"
#include "df.h"
#include "except.h"
for (; link; link = link->next)
{
fprintf (file, "%c%d(bb %d insn %d) ",
- DF_REF_REG_DEF_P (link->ref) ? 'd' : 'u',
+ DF_REF_REG_DEF_P (link->ref)
+ ? 'd'
+ : (DF_REF_FLAGS (link->ref) & DF_REF_IN_NOTE) ? 'e' : 'u',
DF_REF_ID (link->ref),
DF_REF_BBNO (link->ref),
- DF_REF_IS_ARTIFICIAL (link->ref) ? -1 : DF_REF_INSN_UID (link->ref));
+ DF_REF_IS_ARTIFICIAL (link->ref)
+ ? -1 : DF_REF_INSN_UID (link->ref));
}
fprintf (file, "}");
}
blocks within infinite loops. */
if (!reload_completed)
{
+ unsigned int pic_offset_table_regnum = PIC_OFFSET_TABLE_REGNUM;
/* Any reference to any pseudo before reload is a potential
reference of the frame pointer. */
bitmap_set_bit (&df->hardware_regs_used, FRAME_POINTER_REGNUM);
/* Any constant, or pseudo with constant equivalences, may
require reloading from memory using the pic register. */
- if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
- && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
- bitmap_set_bit (&df->hardware_regs_used, PIC_OFFSET_TABLE_REGNUM);
+ if (pic_offset_table_regnum != INVALID_REGNUM
+ && fixed_regs[pic_offset_table_regnum])
+ bitmap_set_bit (&df->hardware_regs_used, pic_offset_table_regnum);
}
EXECUTE_IF_SET_IN_BITMAP (df_lr->out_of_date_transfer_functions, 0, bb_index, bi)
\f
/*----------------------------------------------------------------------------
- BYTE LEVEL LIVE REGISTERS
+ WORD LEVEL LIVE REGISTERS
Find the locations in the function where any use of a pseudo can
reach in the backwards direction. In and out bitvectors are built
- for each basic block. There are two mapping functions,
- df_byte_lr_get_regno_start and df_byte_lr_get_regno_len that are
- used to map regnos into bit vector positions.
-
- This problem differs from the regular df_lr function in the way
- that subregs, *_extracts and strict_low_parts are handled. In lr
- these are consider partial kills, here, the exact set of bytes is
- modeled. Note that any reg that has none of these operations is
- only modeled with a single bit since all operations access the
- entire register.
-
- This problem is more brittle that the regular lr. It currently can
- be used in dce incrementally, but cannot be used in an environment
- where insns are created or modified. The problem is that the
- mapping of regnos to bitmap positions is relatively compact, in
- that if a pseudo does not do any of the byte wise operations, only
- one slot is allocated, rather than a slot for each byte. If insn
- are created, where a subreg is used for a reg that had no subregs,
- the mapping would be wrong. Likewise, there are no checks to see
- that new pseudos have been added. These issues could be addressed
- by adding a problem specific flag to not use the compact mapping,
- if there was a need to do so.
+ for each basic block. We only track pseudo registers that have a
+ size of 2 * UNITS_PER_WORD; bitmaps are indexed by 2 * regno and
+ contain two bits corresponding to each of the subwords.
----------------------------------------------------------------------------*/
/* Private data used to verify the solution for this problem. */
-struct df_byte_lr_problem_data
+struct df_word_lr_problem_data
{
- /* Expanded versions of bitvectors used in lr. */
- bitmap_head invalidated_by_call;
- bitmap_head hardware_regs_used;
-
- /* Indexed by regno, this is true if there are subregs, extracts or
- strict_low_parts for this regno. */
- bitmap_head needs_expansion;
-
- /* The start position and len for each regno in the various bit
- vectors. */
- unsigned int* regno_start;
- unsigned int* regno_len;
/* An obstack for the bitmaps we need for this problem. */
- bitmap_obstack byte_lr_bitmaps;
+ bitmap_obstack word_lr_bitmaps;
};
-/* Get the starting location for REGNO in the df_byte_lr bitmaps. */
-
-int
-df_byte_lr_get_regno_start (unsigned int regno)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;;
- return problem_data->regno_start[regno];
-}
-
-
-/* Get the len for REGNO in the df_byte_lr bitmaps. */
-
-int
-df_byte_lr_get_regno_len (unsigned int regno)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;;
- return problem_data->regno_len[regno];
-}
-
-
/* Free basic block info. */
static void
-df_byte_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
+df_word_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_byte_lr_bb_info *bb_info = (struct df_byte_lr_bb_info *) vbb_info;
+ struct df_word_lr_bb_info *bb_info = (struct df_word_lr_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->use);
}
-/* Check all of the refs in REF_REC to see if any of them are
- extracts, subregs or strict_low_parts. */
-
-static void
-df_byte_lr_check_regs (df_ref *ref_rec)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
-
- for (; *ref_rec; ref_rec++)
- {
- df_ref ref = *ref_rec;
- if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT
- | DF_REF_ZERO_EXTRACT
- | DF_REF_STRICT_LOW_PART)
- || GET_CODE (DF_REF_REG (ref)) == SUBREG)
- bitmap_set_bit (&problem_data->needs_expansion, DF_REF_REGNO (ref));
- }
-}
-
-
-/* Expand bitmap SRC which is indexed by regno to DEST which is indexed by
- regno_start and regno_len. */
-
-static void
-df_byte_lr_expand_bitmap (bitmap dest, bitmap src)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- bitmap_iterator bi;
- unsigned int i;
-
- bitmap_clear (dest);
- EXECUTE_IF_SET_IN_BITMAP (src, 0, i, bi)
- {
- bitmap_set_range (dest, problem_data->regno_start[i],
- problem_data->regno_len[i]);
- }
-}
-
-
-/* Allocate or reset bitmaps for DF_BYTE_LR blocks. The solution bits are
+/* Allocate or reset bitmaps for DF_WORD_LR blocks. The solution bits are
not touched unless the block is new. */
static void
-df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
+df_word_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
{
unsigned int bb_index;
bitmap_iterator bi;
basic_block bb;
- unsigned int regno;
- unsigned int index = 0;
- unsigned int max_reg = max_reg_num();
- struct df_byte_lr_problem_data *problem_data
- = XNEW (struct df_byte_lr_problem_data);
+ struct df_word_lr_problem_data *problem_data
+ = XNEW (struct df_word_lr_problem_data);
- df_byte_lr->problem_data = problem_data;
+ df_word_lr->problem_data = problem_data;
- df_grow_bb_info (df_byte_lr);
+ df_grow_bb_info (df_word_lr);
/* Create the mapping from regnos to slots. This does not change
unless the problem is destroyed and recreated. In particular, if
want to redo the mapping because this would invalidate everything
else. */
- bitmap_obstack_initialize (&problem_data->byte_lr_bitmaps);
- problem_data->regno_start = XNEWVEC (unsigned int, max_reg);
- problem_data->regno_len = XNEWVEC (unsigned int, max_reg);
- bitmap_initialize (&problem_data->hardware_regs_used,
- &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&problem_data->invalidated_by_call,
- &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&problem_data->needs_expansion,
- &problem_data->byte_lr_bitmaps);
-
- /* Discover which regno's use subregs, extracts or
- strict_low_parts. */
- FOR_EACH_BB (bb)
- {
- rtx insn;
- FOR_BB_INSNS (bb, insn)
- {
- if (INSN_P (insn))
- {
- struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
- df_byte_lr_check_regs (DF_INSN_INFO_DEFS (insn_info));
- df_byte_lr_check_regs (DF_INSN_INFO_USES (insn_info));
- }
- }
- bitmap_set_bit (df_byte_lr->out_of_date_transfer_functions, bb->index);
- }
-
- bitmap_set_bit (df_byte_lr->out_of_date_transfer_functions, ENTRY_BLOCK);
- bitmap_set_bit (df_byte_lr->out_of_date_transfer_functions, EXIT_BLOCK);
-
- /* Allocate the slots for each regno. */
- for (regno = 0; regno < max_reg; regno++)
- {
- int len;
- problem_data->regno_start[regno] = index;
- if (bitmap_bit_p (&problem_data->needs_expansion, regno))
- len = GET_MODE_SIZE (GET_MODE (regno_reg_rtx[regno]));
- else
- len = 1;
+ bitmap_obstack_initialize (&problem_data->word_lr_bitmaps);
- problem_data->regno_len[regno] = len;
- index += len;
- }
+ FOR_EACH_BB (bb)
+ bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, bb->index);
- df_byte_lr_expand_bitmap (&problem_data->hardware_regs_used,
- &df->hardware_regs_used);
- df_byte_lr_expand_bitmap (&problem_data->invalidated_by_call,
- regs_invalidated_by_call_regset);
+ bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, ENTRY_BLOCK);
+ bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, EXIT_BLOCK);
- EXECUTE_IF_SET_IN_BITMAP (df_byte_lr->out_of_date_transfer_functions, 0, bb_index, bi)
+ EXECUTE_IF_SET_IN_BITMAP (df_word_lr->out_of_date_transfer_functions, 0, bb_index, bi)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
/* When bitmaps are already initialized, just clear them. */
if (bb_info->use.obstack)
}
else
{
- bitmap_initialize (&bb_info->use, &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&bb_info->def, &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&bb_info->in, &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&bb_info->out, &problem_data->byte_lr_bitmaps);
+ bitmap_initialize (&bb_info->use, &problem_data->word_lr_bitmaps);
+ bitmap_initialize (&bb_info->def, &problem_data->word_lr_bitmaps);
+ bitmap_initialize (&bb_info->in, &problem_data->word_lr_bitmaps);
+ bitmap_initialize (&bb_info->out, &problem_data->word_lr_bitmaps);
}
}
- df_byte_lr->optional_p = true;
+ df_word_lr->optional_p = true;
}
/* Reset the global solution for recalculation. */
static void
-df_byte_lr_reset (bitmap all_blocks)
+df_word_lr_reset (bitmap all_blocks)
{
unsigned int bb_index;
bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
gcc_assert (bb_info);
bitmap_clear (&bb_info->in);
bitmap_clear (&bb_info->out);
}
}
+/* Examine REF, and if it is for a reg we're interested in, set or
+ clear the bits corresponding to its subwords from the bitmap
+ according to IS_SET. LIVE is the bitmap we should update. We do
+ not track hard regs or pseudos of any size other than 2 *
+ UNITS_PER_WORD.
+ We return true if we changed the bitmap, or if we encountered a register
+ we're not tracking. */
+
+bool
+df_word_lr_mark_ref (df_ref ref, bool is_set, regset live)
+{
+ rtx orig_reg = DF_REF_REG (ref);
+ rtx reg = orig_reg;
+ enum machine_mode reg_mode;
+ unsigned regno;
+ /* Left at -1 for whole accesses. */
+ int which_subword = -1;
+ bool changed = false;
+
+ if (GET_CODE (reg) == SUBREG)
+ reg = SUBREG_REG (orig_reg);
+ regno = REGNO (reg);
+ reg_mode = GET_MODE (reg);
+ if (regno < FIRST_PSEUDO_REGISTER
+ || GET_MODE_SIZE (reg_mode) != 2 * UNITS_PER_WORD)
+ return true;
+
+ if (GET_CODE (orig_reg) == SUBREG
+ && df_read_modify_subreg_p (orig_reg))
+ {
+ gcc_assert (DF_REF_FLAGS_IS_SET (ref, DF_REF_PARTIAL));
+ if (subreg_lowpart_p (orig_reg))
+ which_subword = 0;
+ else
+ which_subword = 1;
+ }
+ if (is_set)
+ {
+ if (which_subword != 1)
+ changed |= bitmap_set_bit (live, regno * 2);
+ if (which_subword != 0)
+ changed |= bitmap_set_bit (live, regno * 2 + 1);
+ }
+ else
+ {
+ if (which_subword != 1)
+ changed |= bitmap_clear_bit (live, regno * 2);
+ if (which_subword != 0)
+ changed |= bitmap_clear_bit (live, regno * 2 + 1);
+ }
+ return changed;
+}
/* Compute local live register info for basic block BB. */
static void
-df_byte_lr_bb_local_compute (unsigned int bb_index)
+df_word_lr_bb_local_compute (unsigned int bb_index)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
basic_block bb = BASIC_BLOCK (bb_index);
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
rtx insn;
df_ref *def_rec;
df_ref *use_rec;
- /* Process the registers set in an exception handler. */
+ /* Ensure that artificial refs don't contain references to pseudos. */
for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
{
df_ref def = *def_rec;
- if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_set_range (&bb_info->def, start, len);
- bitmap_clear_range (&bb_info->use, start, len);
- }
+ gcc_assert (DF_REF_REGNO (def) < FIRST_PSEUDO_REGISTER);
}
- /* Process the hardware registers that are always live. */
for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
{
df_ref use = *use_rec;
- /* Add use to set of uses in this BB. */
- if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (&bb_info->use, start, len);
- }
+ gcc_assert (DF_REF_REGNO (use) < FIRST_PSEUDO_REGISTER);
}
FOR_BB_INSNS_REVERSE (bb, insn)
{
unsigned int uid = INSN_UID (insn);
- if (!INSN_P (insn))
+ if (!NONDEBUG_INSN_P (insn))
continue;
-
for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
{
df_ref def = *def_rec;
not kill the other defs that reach here. */
if (!(DF_REF_FLAGS (def) & (DF_REF_CONDITIONAL)))
{
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- unsigned int sb;
- unsigned int lb;
- if (!df_compute_accessed_bytes (def, DF_MM_MUST, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
- if (len)
- {
- bitmap_set_range (&bb_info->def, start, len);
- bitmap_clear_range (&bb_info->use, start, len);
- }
+ df_word_lr_mark_ref (def, true, &bb_info->def);
+ df_word_lr_mark_ref (def, false, &bb_info->use);
}
}
-
for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
{
df_ref use = *use_rec;
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- unsigned int sb;
- unsigned int lb;
- if (!df_compute_accessed_bytes (use, DF_MM_MAY, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
- /* Add use to set of uses in this BB. */
- if (len)
- bitmap_set_range (&bb_info->use, start, len);
+ df_word_lr_mark_ref (use, true, &bb_info->use);
}
}
-
- /* Process the registers set in an exception handler or the hard
- frame pointer if this block is the target of a non local
- goto. */
- for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
- {
- df_ref def = *def_rec;
- if (DF_REF_FLAGS (def) & DF_REF_AT_TOP)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_set_range (&bb_info->def, start, len);
- bitmap_clear_range (&bb_info->use, start, len);
- }
- }
-
-#ifdef EH_USES
- /* Process the uses that are live into an exception handler. */
- for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- /* Add use to set of uses in this BB. */
- if (DF_REF_FLAGS (use) & DF_REF_AT_TOP)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (&bb_info->use, start, len);
- }
- }
-#endif
}
/* Compute local live register info for each basic block within BLOCKS. */
static void
-df_byte_lr_local_compute (bitmap all_blocks ATTRIBUTE_UNUSED)
+df_word_lr_local_compute (bitmap all_blocks ATTRIBUTE_UNUSED)
{
unsigned int bb_index;
bitmap_iterator bi;
- EXECUTE_IF_SET_IN_BITMAP (df_byte_lr->out_of_date_transfer_functions, 0, bb_index, bi)
+ EXECUTE_IF_SET_IN_BITMAP (df_word_lr->out_of_date_transfer_functions, 0, bb_index, bi)
{
if (bb_index == EXIT_BLOCK)
{
- /* The exit block is special for this problem and its bits are
- computed from thin air. */
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (EXIT_BLOCK);
- df_byte_lr_expand_bitmap (&bb_info->use, df->exit_block_uses);
+ unsigned regno;
+ bitmap_iterator bi;
+ EXECUTE_IF_SET_IN_BITMAP (df->exit_block_uses, FIRST_PSEUDO_REGISTER,
+ regno, bi)
+ gcc_unreachable ();
}
else
- df_byte_lr_bb_local_compute (bb_index);
+ df_word_lr_bb_local_compute (bb_index);
}
- bitmap_clear (df_byte_lr->out_of_date_transfer_functions);
+ bitmap_clear (df_word_lr->out_of_date_transfer_functions);
}
/* Initialize the solution vectors. */
static void
-df_byte_lr_init (bitmap all_blocks)
+df_word_lr_init (bitmap all_blocks)
{
unsigned int bb_index;
bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
bitmap_copy (&bb_info->in, &bb_info->use);
bitmap_clear (&bb_info->out);
}
}
-/* Confluence function that processes infinite loops. This might be a
- noreturn function that throws. And even if it isn't, getting the
- unwind info right helps debugging. */
-static void
-df_byte_lr_confluence_0 (basic_block bb)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- bitmap op1 = &df_byte_lr_get_bb_info (bb->index)->out;
- if (bb != EXIT_BLOCK_PTR)
- bitmap_copy (op1, &problem_data->hardware_regs_used);
-}
-
-
/* Confluence function that ignores fake edges. */
static bool
-df_byte_lr_confluence_n (edge e)
+df_word_lr_confluence_n (edge e)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- bitmap op1 = &df_byte_lr_get_bb_info (e->src->index)->out;
- bitmap op2 = &df_byte_lr_get_bb_info (e->dest->index)->in;
- bool changed = false;
+ bitmap op1 = &df_word_lr_get_bb_info (e->src->index)->out;
+ bitmap op2 = &df_word_lr_get_bb_info (e->dest->index)->in;
- /* Call-clobbered registers die across exception and call edges. */
- /* ??? Abnormal call edges ignored for the moment, as this gets
- confused by sibling call edges, which crashes reg-stack. */
- if (e->flags & EDGE_EH)
- changed = bitmap_ior_and_compl_into (op1, op2,
- &problem_data->invalidated_by_call);
- else
- changed = bitmap_ior_into (op1, op2);
-
- changed |= bitmap_ior_into (op1, &problem_data->hardware_regs_used);
- return changed;
+ return bitmap_ior_into (op1, op2);
}
/* Transfer function. */
static bool
-df_byte_lr_transfer_function (int bb_index)
+df_word_lr_transfer_function (int bb_index)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
bitmap in = &bb_info->in;
bitmap out = &bb_info->out;
bitmap use = &bb_info->use;
/* Free all storage associated with the problem. */
static void
-df_byte_lr_free (void)
+df_word_lr_free (void)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
-
+ struct df_word_lr_problem_data *problem_data
+ = (struct df_word_lr_problem_data *)df_word_lr->problem_data;
- if (df_byte_lr->block_info)
+ if (df_word_lr->block_info)
{
- df_byte_lr->block_info_size = 0;
- free (df_byte_lr->block_info);
- df_byte_lr->block_info = NULL;
+ df_word_lr->block_info_size = 0;
+ free (df_word_lr->block_info);
+ df_word_lr->block_info = NULL;
}
- BITMAP_FREE (df_byte_lr->out_of_date_transfer_functions);
- bitmap_obstack_release (&problem_data->byte_lr_bitmaps);
- free (problem_data->regno_start);
- free (problem_data->regno_len);
+ BITMAP_FREE (df_word_lr->out_of_date_transfer_functions);
+ bitmap_obstack_release (&problem_data->word_lr_bitmaps);
free (problem_data);
- free (df_byte_lr);
+ free (df_word_lr);
}
/* Debugging info at top of bb. */
static void
-df_byte_lr_top_dump (basic_block bb, FILE *file)
+df_word_lr_top_dump (basic_block bb, FILE *file)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb->index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
if (!bb_info)
return;
fprintf (file, ";; blr in \t");
- df_print_byte_regset (file, &bb_info->in);
+ df_print_word_regset (file, &bb_info->in);
fprintf (file, ";; blr use \t");
- df_print_byte_regset (file, &bb_info->use);
+ df_print_word_regset (file, &bb_info->use);
fprintf (file, ";; blr def \t");
- df_print_byte_regset (file, &bb_info->def);
+ df_print_word_regset (file, &bb_info->def);
}
/* Debugging info at bottom of bb. */
static void
-df_byte_lr_bottom_dump (basic_block bb, FILE *file)
+df_word_lr_bottom_dump (basic_block bb, FILE *file)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb->index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
if (!bb_info)
return;
fprintf (file, ";; blr out \t");
- df_print_byte_regset (file, &bb_info->out);
+ df_print_word_regset (file, &bb_info->out);
}
/* All of the information associated with every instance of the problem. */
-static struct df_problem problem_BYTE_LR =
+static struct df_problem problem_WORD_LR =
{
- DF_BYTE_LR, /* Problem id. */
+ DF_WORD_LR, /* Problem id. */
DF_BACKWARD, /* Direction. */
- df_byte_lr_alloc, /* Allocate the problem specific data. */
- df_byte_lr_reset, /* Reset global information. */
- df_byte_lr_free_bb_info, /* Free basic block info. */
- df_byte_lr_local_compute, /* Local compute function. */
- df_byte_lr_init, /* Init the solution specific data. */
+ df_word_lr_alloc, /* Allocate the problem specific data. */
+ df_word_lr_reset, /* Reset global information. */
+ df_word_lr_free_bb_info, /* Free basic block info. */
+ df_word_lr_local_compute, /* Local compute function. */
+ df_word_lr_init, /* Init the solution specific data. */
df_worklist_dataflow, /* Worklist solver. */
- df_byte_lr_confluence_0, /* Confluence operator 0. */
- df_byte_lr_confluence_n, /* Confluence operator n. */
- df_byte_lr_transfer_function, /* Transfer function. */
+ NULL, /* Confluence operator 0. */
+ df_word_lr_confluence_n, /* Confluence operator n. */
+ df_word_lr_transfer_function, /* Transfer function. */
NULL, /* Finalize function. */
- df_byte_lr_free, /* Free all of the problem information. */
- df_byte_lr_free, /* Remove this problem from the stack of dataflow problems. */
+ df_word_lr_free, /* Free all of the problem information. */
+ df_word_lr_free, /* Remove this problem from the stack of dataflow problems. */
NULL, /* Debugging. */
- df_byte_lr_top_dump, /* Debugging start block. */
- df_byte_lr_bottom_dump, /* Debugging end block. */
+ df_word_lr_top_dump, /* Debugging start block. */
+ df_word_lr_bottom_dump, /* Debugging end block. */
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
- sizeof (struct df_byte_lr_bb_info),/* Size of entry of block_info array. */
- TV_DF_BYTE_LR, /* Timing variable. */
+ sizeof (struct df_word_lr_bb_info),/* Size of entry of block_info array. */
+ TV_DF_WORD_LR, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
solution. */
void
-df_byte_lr_add_problem (void)
+df_word_lr_add_problem (void)
{
- df_add_problem (&problem_BYTE_LR);
+ df_add_problem (&problem_WORD_LR);
/* These will be initialized when df_scan_blocks processes each
block. */
- df_byte_lr->out_of_date_transfer_functions = BITMAP_ALLOC (NULL);
+ df_word_lr->out_of_date_transfer_functions = BITMAP_ALLOC (NULL);
}
-/* Simulate the effects of the defs of INSN on LIVE. */
+/* Simulate the effects of the defs of INSN on LIVE. Return true if we changed
+ any bits, which is used by the caller to determine whether a set is
+ necessary. We also return true if there are other reasons not to delete
+ an insn. */
-void
-df_byte_lr_simulate_defs (rtx insn, bitmap live)
+bool
+df_word_lr_simulate_defs (rtx insn, bitmap live)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
+ bool changed = false;
df_ref *def_rec;
unsigned int uid = INSN_UID (insn);
for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
{
df_ref def = *def_rec;
-
- /* If the def is to only part of the reg, it does
- not kill the other defs that reach here. */
- if (!(DF_REF_FLAGS (def) & DF_REF_CONDITIONAL))
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- unsigned int sb;
- unsigned int lb;
- if (!df_compute_accessed_bytes (def, DF_MM_MUST, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
-
- if (len)
- bitmap_clear_range (live, start, len);
- }
+ if (DF_REF_FLAGS (def) & DF_REF_CONDITIONAL)
+ changed = true;
+ else
+ changed |= df_word_lr_mark_ref (*def_rec, false, live);
}
+ return changed;
}
/* Simulate the effects of the uses of INSN on LIVE. */
void
-df_byte_lr_simulate_uses (rtx insn, bitmap live)
+df_word_lr_simulate_uses (rtx insn, bitmap live)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
df_ref *use_rec;
unsigned int uid = INSN_UID (insn);
for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- unsigned int sb;
- unsigned int lb;
-
- if (!df_compute_accessed_bytes (use, DF_MM_MAY, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
-
- /* Add use to set of uses in this BB. */
- if (len)
- bitmap_set_range (live, start, len);
- }
+ df_word_lr_mark_ref (*use_rec, true, live);
}
-
-
-/* Apply the artificial uses and defs at the top of BB in a forwards
- direction. */
-
-void
-df_byte_lr_simulate_artificial_refs_at_top (basic_block bb, bitmap live)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- df_ref *def_rec;
-#ifdef EH_USES
- df_ref *use_rec;
-#endif
- int bb_index = bb->index;
-
-#ifdef EH_USES
- for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- if (DF_REF_FLAGS (use) & DF_REF_AT_TOP)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (live, start, len);
- }
- }
-#endif
-
- for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
- {
- df_ref def = *def_rec;
- if (DF_REF_FLAGS (def) & DF_REF_AT_TOP)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_clear_range (live, start, len);
- }
- }
-}
-
-
-/* Apply the artificial uses and defs at the end of BB in a backwards
- direction. */
-
-void
-df_byte_lr_simulate_artificial_refs_at_end (basic_block bb, bitmap live)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- df_ref *def_rec;
- df_ref *use_rec;
- int bb_index = bb->index;
-
- for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
- {
- df_ref def = *def_rec;
- if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_clear_range (live, start, len);
- }
- }
-
- for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (live, start, len);
- }
- }
-}
-
-
\f
/*----------------------------------------------------------------------------
This problem computes REG_DEAD and REG_UNUSED notes.
/* Remove all of the REG_DEAD or REG_UNUSED notes from INSN and add
- them to OLD_DEAD_NOTES and OLD_UNUSED_NOTES. */
+ them to OLD_DEAD_NOTES and OLD_UNUSED_NOTES. Remove also
+ REG_EQUAL/REG_EQUIV notes referring to dead pseudos using LIVE
+ as the bitmap of currently live registers. */
static void
-df_kill_notes (rtx insn)
+df_kill_notes (rtx insn, bitmap live)
{
rtx *pprev = ®_NOTES (insn);
rtx link = *pprev;
}
break;
+ case REG_EQUAL:
+ case REG_EQUIV:
+ {
+ /* Remove the notes that refer to dead registers. As we have at most
+ one REG_EQUAL/EQUIV note, all of EQ_USES will refer to this note
+ so we need to purge the complete EQ_USES vector when removing
+ the note using df_notes_rescan. */
+ df_ref *use_rec;
+ bool deleted = false;
+
+ for (use_rec = DF_INSN_EQ_USES (insn); *use_rec; use_rec++)
+ {
+ df_ref use = *use_rec;
+ if (DF_REF_REGNO (use) > FIRST_PSEUDO_REGISTER
+ && DF_REF_LOC (use)
+ && (DF_REF_FLAGS (use) & DF_REF_IN_NOTE)
+ && ! bitmap_bit_p (live, DF_REF_REGNO (use))
+ && loc_mentioned_in_p (DF_REF_LOC (use), XEXP (link, 0)))
+ {
+ deleted = true;
+ break;
+ }
+ }
+ if (deleted)
+ {
+ rtx next;
+#ifdef REG_DEAD_DEBUGGING
+ df_print_note ("deleting: ", insn, link);
+#endif
+ next = XEXP (link, 1);
+ free_EXPR_LIST_node (link);
+ *pprev = link = next;
+ df_notes_rescan (insn);
+ }
+ else
+ {
+ pprev = &XEXP (link, 1);
+ link = *pprev;
+ }
+ break;
+ }
default:
pprev = &XEXP (link, 1);
link = *pprev;
return true;
}
+
+/* Node of a linked list of uses of dead REGs in debug insns. */
+struct dead_debug_use
+{
+ df_ref use;
+ struct dead_debug_use *next;
+};
+
+/* Linked list of the above, with a bitmap of the REGs in the
+ list. */
+struct dead_debug
+{
+ struct dead_debug_use *head;
+ bitmap used;
+ bitmap to_rescan;
+};
+
+static void dead_debug_reset (struct dead_debug *, unsigned int);
+
+
/* Set the REG_UNUSED notes for the multiword hardreg defs in INSN
based on the bits in LIVE. Do not generate notes for registers in
artificial uses. DO_NOT_GEN is updated so that REG_DEAD notes are
static void
df_set_unused_notes_for_mw (rtx insn, struct df_mw_hardreg *mws,
bitmap live, bitmap do_not_gen,
- bitmap artificial_uses)
+ bitmap artificial_uses,
+ struct dead_debug *debug)
{
unsigned int r;
{
unsigned int regno = mws->start_regno;
df_set_note (REG_UNUSED, insn, mws->mw_reg);
+ dead_debug_reset (debug, regno);
#ifdef REG_DEAD_DEBUGGING
df_print_note ("adding 1: ", insn, REG_NOTES (insn));
&& !bitmap_bit_p (artificial_uses, r))
{
df_set_note (REG_UNUSED, insn, regno_reg_rtx[r]);
+ dead_debug_reset (debug, r);
#ifdef REG_DEAD_DEBUGGING
df_print_note ("adding 2: ", insn, REG_NOTES (insn));
#endif
static void
df_create_unused_note (rtx insn, df_ref def,
- bitmap live, bitmap artificial_uses)
+ bitmap live, bitmap artificial_uses,
+ struct dead_debug *debug)
{
unsigned int dregno = DF_REF_REGNO (def);
rtx reg = (DF_REF_LOC (def))
? *DF_REF_REAL_LOC (def): DF_REF_REG (def);
df_set_note (REG_UNUSED, insn, reg);
+ dead_debug_reset (debug, dregno);
#ifdef REG_DEAD_DEBUGGING
df_print_note ("adding 3: ", insn, REG_NOTES (insn));
#endif
return;
}
-/* Node of a linked list of uses of dead REGs in debug insns. */
-struct dead_debug_use
-{
- df_ref use;
- struct dead_debug_use *next;
-};
-
-/* Linked list of the above, with a bitmap of the REGs in the
- list. */
-struct dead_debug
-{
- struct dead_debug_use *head;
- bitmap used;
- bitmap to_rescan;
-};
/* Initialize DEBUG to an empty list, and clear USED, if given. */
static inline void
}
}
+/* Reset DEBUG_INSNs with pending uses of DREGNO. */
+static void
+dead_debug_reset (struct dead_debug *debug, unsigned int dregno)
+{
+ struct dead_debug_use **tailp = &debug->head;
+ struct dead_debug_use **insnp = &debug->head;
+ struct dead_debug_use *cur;
+ rtx insn;
+
+ if (!debug->used || !bitmap_clear_bit (debug->used, dregno))
+ return;
+
+ while ((cur = *tailp))
+ {
+ if (DF_REF_REGNO (cur->use) == dregno)
+ {
+ *tailp = cur->next;
+ insn = DF_REF_INSN (cur->use);
+ INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
+ if (debug->to_rescan == NULL)
+ debug->to_rescan = BITMAP_ALLOC (NULL);
+ bitmap_set_bit (debug->to_rescan, INSN_UID (insn));
+ XDELETE (cur);
+ /* If the current use isn't the first one attached to INSN, go back
+ to this first use. We assume that the uses attached to an insn
+ are adjacent. */
+ if (tailp != insnp && DF_REF_INSN ((*insnp)->use) == insn)
+ tailp = insnp;
+ /* Then remove all the other uses attached to INSN. */
+ while ((cur = *tailp) && DF_REF_INSN (cur->use) == insn)
+ {
+ *tailp = cur->next;
+ XDELETE (cur);
+ }
+ insnp = tailp;
+ }
+ else
+ {
+ if (DF_REF_INSN ((*insnp)->use) != DF_REF_INSN (cur->use))
+ insnp = tailp;
+ tailp = &(*tailp)->next;
+ }
+ }
+}
+
/* Add USE to DEBUG. It must be a dead reference to UREGNO in a debug
insn. Create a bitmap for DEBUG as needed. */
static inline void
tailp = &(*tailp)->next;
}
- gcc_assert (reg);
+ /* We may have dangling bits in debug->used for registers that were part
+ of a multi-register use, one component of which has been reset. */
+ if (reg == NULL)
+ return;
/* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
dval = make_debug_expr_from_rtl (reg);
debug_insn = DEBUG_INSN_P (insn);
bitmap_clear (do_not_gen);
- df_kill_notes (insn);
+ df_kill_notes (insn, live);
/* Process the defs. */
if (CALL_P (insn))
&& !df_ignore_stack_reg (mws->start_regno))
df_set_unused_notes_for_mw (insn,
mws, live, do_not_gen,
- artificial_uses);
+ artificial_uses, &debug);
mws_rec++;
}
if (!DF_REF_FLAGS_IS_SET (def, DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))
{
df_create_unused_note (insn,
- def, live, artificial_uses);
+ def, live, artificial_uses, &debug);
bitmap_set_bit (do_not_gen, dregno);
}
if (DF_MWS_REG_DEF_P (mws))
df_set_unused_notes_for_mw (insn,
mws, live, do_not_gen,
- artificial_uses);
+ artificial_uses, &debug);
mws_rec++;
}
df_ref def = *def_rec;
unsigned int dregno = DF_REF_REGNO (def);
df_create_unused_note (insn,
- def, live, artificial_uses);
+ def, live, artificial_uses, &debug);
if (!DF_REF_FLAGS_IS_SET (def, DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))
bitmap_set_bit (do_not_gen, dregno);
while (*mws_rec)
{
struct df_mw_hardreg *mws = *mws_rec;
- if ((DF_MWS_REG_DEF_P (mws))
+ if (DF_MWS_REG_USE_P (mws)
&& !df_ignore_stack_reg (mws->start_regno))
{
bool really_add_notes = debug_insn != 0;
}
}
+/* Find the set of uses for INSN. This includes partial defs. */
+
+static void
+df_simulate_find_uses (rtx insn, bitmap uses)
+{
+ df_ref *rec;
+ unsigned int uid = INSN_UID (insn);
+
+ for (rec = DF_INSN_UID_DEFS (uid); *rec; rec++)
+ {
+ df_ref def = *rec;
+ if (DF_REF_FLAGS (def) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL))
+ bitmap_set_bit (uses, DF_REF_REGNO (def));
+ }
+ for (rec = DF_INSN_UID_USES (uid); *rec; rec++)
+ {
+ df_ref use = *rec;
+ bitmap_set_bit (uses, DF_REF_REGNO (use));
+ }
+}
+
/* Find the set of real DEFs, which are not clobbers, for INSN. */
void
{
rtx reg = XEXP (link, 0);
int regno = REGNO (reg);
- if (regno < FIRST_PSEUDO_REGISTER)
- {
- int n = hard_regno_nregs[regno][GET_MODE (reg)];
- while (--n >= 0)
- bitmap_clear_bit (live, regno + n);
- }
+ if (HARD_REGISTER_NUM_P (regno))
+ bitmap_clear_range (live, regno,
+ hard_regno_nregs[regno][GET_MODE (reg)]);
else
bitmap_clear_bit (live, regno);
}
}
df_simulate_fixup_sets (bb, live);
}
+\f
+/* Used by the next two functions to encode information about the
+ memory references we found. */
+#define MEMREF_NORMAL 1
+#define MEMREF_VOLATILE 2
+
+/* A subroutine of can_move_insns_across_p called through for_each_rtx.
+ Return either MEMREF_NORMAL or MEMREF_VOLATILE if a memory is found. */
+
+static int
+find_memory (rtx *px, void *data ATTRIBUTE_UNUSED)
+{
+ rtx x = *px;
+
+ if (GET_CODE (x) == ASM_OPERANDS && MEM_VOLATILE_P (x))
+ return MEMREF_VOLATILE;
+
+ if (!MEM_P (x))
+ return 0;
+ if (MEM_VOLATILE_P (x))
+ return MEMREF_VOLATILE;
+ if (MEM_READONLY_P (x))
+ return 0;
+
+ return MEMREF_NORMAL;
+}
+
+/* A subroutine of can_move_insns_across_p called through note_stores.
+ DATA points to an integer in which we set either the bit for
+ MEMREF_NORMAL or the bit for MEMREF_VOLATILE if we find a MEM
+ of either kind. */
+
+static void
+find_memory_stores (rtx x, const_rtx pat ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
+{
+ int *pflags = (int *)data;
+ if (GET_CODE (x) == SUBREG)
+ x = XEXP (x, 0);
+ /* Treat stores to SP as stores to memory, this will prevent problems
+ when there are references to the stack frame. */
+ if (x == stack_pointer_rtx)
+ *pflags |= MEMREF_VOLATILE;
+ if (!MEM_P (x))
+ return;
+ *pflags |= MEM_VOLATILE_P (x) ? MEMREF_VOLATILE : MEMREF_NORMAL;
+}
+
+/* Scan BB backwards, using df_simulate functions to keep track of
+ lifetimes, up to insn POINT. The result is stored in LIVE. */
+
+void
+simulate_backwards_to_point (basic_block bb, regset live, rtx point)
+{
+ rtx insn;
+ bitmap_copy (live, df_get_live_out (bb));
+ df_simulate_initialize_backwards (bb, live);
+
+ /* Scan and update life information until we reach the point we're
+ interested in. */
+ for (insn = BB_END (bb); insn != point; insn = PREV_INSN (insn))
+ df_simulate_one_insn_backwards (bb, insn, live);
+}
+
+/* Return true if it is safe to move a group of insns, described by
+ the range FROM to TO, backwards across another group of insns,
+ described by ACROSS_FROM to ACROSS_TO. It is assumed that there
+ are no insns between ACROSS_TO and FROM, but they may be in
+ different basic blocks; MERGE_BB is the block from which the
+ insns will be moved. The caller must pass in a regset MERGE_LIVE
+ which specifies the registers live after TO.
+
+ This function may be called in one of two cases: either we try to
+ move identical instructions from all successor blocks into their
+ predecessor, or we try to move from only one successor block. If
+ OTHER_BRANCH_LIVE is nonnull, it indicates that we're dealing with
+ the second case. It should contain a set of registers live at the
+ end of ACROSS_TO which must not be clobbered by moving the insns.
+ In that case, we're also more careful about moving memory references
+ and trapping insns.
+
+ We return false if it is not safe to move the entire group, but it
+ may still be possible to move a subgroup. PMOVE_UPTO, if nonnull,
+ is set to point at the last moveable insn in such a case. */
+
+bool
+can_move_insns_across (rtx from, rtx to, rtx across_from, rtx across_to,
+ basic_block merge_bb, regset merge_live,
+ regset other_branch_live, rtx *pmove_upto)
+{
+ rtx insn, next, max_to;
+ bitmap merge_set, merge_use, local_merge_live;
+ bitmap test_set, test_use;
+ unsigned i, fail = 0;
+ bitmap_iterator bi;
+ int memrefs_in_across = 0;
+ int mem_sets_in_across = 0;
+ bool trapping_insns_in_across = false;
+ if (pmove_upto != NULL)
+ *pmove_upto = NULL_RTX;
+
+ /* Find real bounds, ignoring debug insns. */
+ while (!NONDEBUG_INSN_P (from) && from != to)
+ from = NEXT_INSN (from);
+ while (!NONDEBUG_INSN_P (to) && from != to)
+ to = PREV_INSN (to);
+
+ for (insn = across_to; ; insn = next)
+ {
+ if (CALL_P (insn))
+ {
+ if (RTL_CONST_OR_PURE_CALL_P (insn))
+ /* Pure functions can read from memory. Const functions can
+ read from arguments that the ABI has forced onto the stack.
+ Neither sort of read can be volatile. */
+ memrefs_in_across |= MEMREF_NORMAL;
+ else
+ {
+ memrefs_in_across |= MEMREF_VOLATILE;
+ mem_sets_in_across |= MEMREF_VOLATILE;
+ }
+ }
+ if (NONDEBUG_INSN_P (insn))
+ {
+ memrefs_in_across |= for_each_rtx (&PATTERN (insn), find_memory,
+ NULL);
+ note_stores (PATTERN (insn), find_memory_stores,
+ &mem_sets_in_across);
+ /* This is used just to find sets of the stack pointer. */
+ memrefs_in_across |= mem_sets_in_across;
+ trapping_insns_in_across |= may_trap_p (PATTERN (insn));
+ }
+ next = PREV_INSN (insn);
+ if (insn == across_from)
+ break;
+ }
+
+ /* Collect:
+ MERGE_SET = set of registers set in MERGE_BB
+ MERGE_USE = set of registers used in MERGE_BB and live at its top
+ MERGE_LIVE = set of registers live at the point inside the MERGE
+ range that we've reached during scanning
+ TEST_SET = set of registers set between ACROSS_FROM and ACROSS_END.
+ TEST_USE = set of registers used between ACROSS_FROM and ACROSS_END,
+ and live before ACROSS_FROM. */
+
+ merge_set = BITMAP_ALLOC (®_obstack);
+ merge_use = BITMAP_ALLOC (®_obstack);
+ local_merge_live = BITMAP_ALLOC (®_obstack);
+ test_set = BITMAP_ALLOC (®_obstack);
+ test_use = BITMAP_ALLOC (®_obstack);
+
+ /* Compute the set of registers set and used in the ACROSS range. */
+ if (other_branch_live != NULL)
+ bitmap_copy (test_use, other_branch_live);
+ df_simulate_initialize_backwards (merge_bb, test_use);
+ for (insn = across_to; ; insn = next)
+ {
+ if (NONDEBUG_INSN_P (insn))
+ {
+ df_simulate_find_defs (insn, test_set);
+ df_simulate_defs (insn, test_use);
+ df_simulate_uses (insn, test_use);
+ }
+ next = PREV_INSN (insn);
+ if (insn == across_from)
+ break;
+ }
+
+ /* Compute an upper bound for the amount of insns moved, by finding
+ the first insn in MERGE that sets a register in TEST_USE, or uses
+ a register in TEST_SET. We also check for calls, trapping operations,
+ and memory references. */
+ max_to = NULL_RTX;
+ for (insn = from; ; insn = next)
+ {
+ if (CALL_P (insn))
+ break;
+ if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_EPILOGUE_BEG)
+ break;
+ if (NONDEBUG_INSN_P (insn))
+ {
+ if (may_trap_or_fault_p (PATTERN (insn))
+ && (trapping_insns_in_across || other_branch_live != NULL))
+ break;
+
+ /* We cannot move memory stores past each other, or move memory
+ reads past stores, at least not without tracking them and
+ calling true_dependence on every pair.
+
+ If there is no other branch and no memory references or
+ sets in the ACROSS range, we can move memory references
+ freely, even volatile ones.
+
+ Otherwise, the rules are as follows: volatile memory
+ references and stores can't be moved at all, and any type
+ of memory reference can't be moved if there are volatile
+ accesses or stores in the ACROSS range. That leaves
+ normal reads, which can be moved, as the trapping case is
+ dealt with elsewhere. */
+ if (other_branch_live != NULL || memrefs_in_across != 0)
+ {
+ int mem_ref_flags = 0;
+ int mem_set_flags = 0;
+ note_stores (PATTERN (insn), find_memory_stores, &mem_set_flags);
+ mem_ref_flags = for_each_rtx (&PATTERN (insn), find_memory,
+ NULL);
+ /* Catch sets of the stack pointer. */
+ mem_ref_flags |= mem_set_flags;
+
+ if ((mem_ref_flags | mem_set_flags) & MEMREF_VOLATILE)
+ break;
+ if ((memrefs_in_across & MEMREF_VOLATILE) && mem_ref_flags != 0)
+ break;
+ if (mem_set_flags != 0
+ || (mem_sets_in_across != 0 && mem_ref_flags != 0))
+ break;
+ }
+ df_simulate_find_uses (insn, merge_use);
+ /* We're only interested in uses which use a value live at
+ the top, not one previously set in this block. */
+ bitmap_and_compl_into (merge_use, merge_set);
+ df_simulate_find_defs (insn, merge_set);
+ if (bitmap_intersect_p (merge_set, test_use)
+ || bitmap_intersect_p (merge_use, test_set))
+ break;
+#ifdef HAVE_cc0
+ if (!sets_cc0_p (insn))
+#endif
+ max_to = insn;
+ }
+ next = NEXT_INSN (insn);
+ if (insn == to)
+ break;
+ }
+ if (max_to != to)
+ fail = 1;
+
+ if (max_to == NULL_RTX || (fail && pmove_upto == NULL))
+ goto out;
+
+ /* Now, lower this upper bound by also taking into account that
+ a range of insns moved across ACROSS must not leave a register
+ live at the end that will be clobbered in ACROSS. We need to
+ find a point where TEST_SET & LIVE == 0.
+
+ Insns in the MERGE range that set registers which are also set
+ in the ACROSS range may still be moved as long as we also move
+ later insns which use the results of the set, and make the
+ register dead again. This is verified by the condition stated
+ above. We only need to test it for registers that are set in
+ the moved region.
+
+ MERGE_LIVE is provided by the caller and holds live registers after
+ TO. */
+ bitmap_copy (local_merge_live, merge_live);
+ for (insn = to; insn != max_to; insn = PREV_INSN (insn))
+ df_simulate_one_insn_backwards (merge_bb, insn, local_merge_live);
+
+ /* We're not interested in registers that aren't set in the moved
+ region at all. */
+ bitmap_and_into (local_merge_live, merge_set);
+ for (;;)
+ {
+ if (NONDEBUG_INSN_P (insn))
+ {
+ if (!bitmap_intersect_p (test_set, local_merge_live)
+#ifdef HAVE_cc0
+ && !sets_cc0_p (insn)
+#endif
+ )
+ {
+ max_to = insn;
+ break;
+ }
+
+ df_simulate_one_insn_backwards (merge_bb, insn,
+ local_merge_live);
+ }
+ if (insn == from)
+ {
+ fail = 1;
+ goto out;
+ }
+ insn = PREV_INSN (insn);
+ }
+
+ if (max_to != to)
+ fail = 1;
+
+ if (pmove_upto)
+ *pmove_upto = max_to;
+
+ /* For small register class machines, don't lengthen lifetimes of
+ hard registers before reload. */
+ if (! reload_completed
+ && targetm.small_register_classes_for_mode_p (VOIDmode))
+ {
+ EXECUTE_IF_SET_IN_BITMAP (merge_set, 0, i, bi)
+ {
+ if (i < FIRST_PSEUDO_REGISTER
+ && ! fixed_regs[i]
+ && ! global_regs[i])
+ fail = 1;
+ }
+ }
+
+ out:
+ BITMAP_FREE (merge_set);
+ BITMAP_FREE (merge_use);
+ BITMAP_FREE (local_merge_live);
+ BITMAP_FREE (test_set);
+ BITMAP_FREE (test_use);
+
+ return !fail;
+}
\f
/*----------------------------------------------------------------------------
OSDN Git Service
