/* Standard problems for dataflow support routines.
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009 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"
#define DF_SPARSE_THRESHOLD 32
-static bitmap seen_in_block = NULL;
-static bitmap seen_in_insn = NULL;
+static bitmap_head seen_in_block;
+static bitmap_head seen_in_insn;
\f
/*----------------------------------------------------------------------------
/* Generic versions to get the void* version of the block info. Only
used inside the problem instance vectors. */
-/* Grow the bb_info array. */
-
-void
-df_grow_bb_info (struct dataflow *dflow)
-{
- unsigned int new_size = last_basic_block + 1;
- if (dflow->block_info_size < new_size)
- {
- new_size += new_size / 4;
- dflow->block_info = XRESIZEVEC (void *, dflow->block_info, new_size);
- memset (dflow->block_info + dflow->block_info_size, 0,
- (new_size - dflow->block_info_size) *sizeof (void *));
- dflow->block_info_size = new_size;
- }
-}
-
/* Dump a def-use or use-def chain for REF to FILE. */
void
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, "}");
}
struct df_rd_problem_data
{
/* The set of defs to regs invalidated by call. */
- bitmap sparse_invalidated_by_call;
+ bitmap_head sparse_invalidated_by_call;
/* The set of defs to regs invalidate by call for rd. */
- bitmap dense_invalidated_by_call;
+ bitmap_head dense_invalidated_by_call;
/* An obstack for the bitmaps we need for this problem. */
bitmap_obstack rd_bitmaps;
};
-/* Set basic block info. */
-
-static void
-df_rd_set_bb_info (unsigned int index,
- struct df_rd_bb_info *bb_info)
-{
- gcc_assert (df_rd);
- gcc_assert (index < df_rd->block_info_size);
- df_rd->block_info[index] = bb_info;
-}
-
/* Free basic block info. */
struct df_rd_bb_info *bb_info = (struct df_rd_bb_info *) vbb_info;
if (bb_info)
{
- BITMAP_FREE (bb_info->kill);
- BITMAP_FREE (bb_info->sparse_kill);
- BITMAP_FREE (bb_info->gen);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- pool_free (df_rd->block_pool, bb_info);
+ bitmap_clear (&bb_info->kill);
+ bitmap_clear (&bb_info->sparse_kill);
+ bitmap_clear (&bb_info->gen);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
bitmap_iterator bi;
struct df_rd_problem_data *problem_data;
- if (!df_rd->block_pool)
- df_rd->block_pool = create_alloc_pool ("df_rd_block pool",
- sizeof (struct df_rd_bb_info), 50);
-
if (df_rd->problem_data)
{
problem_data = (struct df_rd_problem_data *) df_rd->problem_data;
- bitmap_clear (problem_data->sparse_invalidated_by_call);
- bitmap_clear (problem_data->dense_invalidated_by_call);
+ bitmap_clear (&problem_data->sparse_invalidated_by_call);
+ bitmap_clear (&problem_data->dense_invalidated_by_call);
}
else
{
df_rd->problem_data = problem_data;
bitmap_obstack_initialize (&problem_data->rd_bitmaps);
- problem_data->sparse_invalidated_by_call
- = BITMAP_ALLOC (&problem_data->rd_bitmaps);
- problem_data->dense_invalidated_by_call
- = BITMAP_ALLOC (&problem_data->rd_bitmaps);
+ bitmap_initialize (&problem_data->sparse_invalidated_by_call,
+ &problem_data->rd_bitmaps);
+ bitmap_initialize (&problem_data->dense_invalidated_by_call,
+ &problem_data->rd_bitmaps);
}
df_grow_bb_info (df_rd);
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
- if (bb_info)
+
+ /* When bitmaps are already initialized, just clear them. */
+ if (bb_info->kill.obstack)
{
- bitmap_clear (bb_info->kill);
- bitmap_clear (bb_info->sparse_kill);
- bitmap_clear (bb_info->gen);
+ bitmap_clear (&bb_info->kill);
+ bitmap_clear (&bb_info->sparse_kill);
+ bitmap_clear (&bb_info->gen);
}
else
{
- bb_info = (struct df_rd_bb_info *) pool_alloc (df_rd->block_pool);
- df_rd_set_bb_info (bb_index, bb_info);
- bb_info->kill = BITMAP_ALLOC (&problem_data->rd_bitmaps);
- bb_info->sparse_kill = BITMAP_ALLOC (&problem_data->rd_bitmaps);
- bb_info->gen = BITMAP_ALLOC (&problem_data->rd_bitmaps);
- bb_info->in = BITMAP_ALLOC (&problem_data->rd_bitmaps);
- bb_info->out = BITMAP_ALLOC (&problem_data->rd_bitmaps);
+ bitmap_initialize (&bb_info->kill, &problem_data->rd_bitmaps);
+ bitmap_initialize (&bb_info->sparse_kill, &problem_data->rd_bitmaps);
+ bitmap_initialize (&bb_info->gen, &problem_data->rd_bitmaps);
+ bitmap_initialize (&bb_info->in, &problem_data->rd_bitmaps);
+ bitmap_initialize (&bb_info->out, &problem_data->rd_bitmaps);
}
}
df_rd->optional_p = true;
{
/* Only the last def(s) for a regno in the block has any
effect. */
- if (!bitmap_bit_p (seen_in_block, regno))
+ if (!bitmap_bit_p (&seen_in_block, regno))
{
/* The first def for regno in insn gets to knock out the
defs from other instructions. */
- if ((!bitmap_bit_p (seen_in_insn, regno))
+ if ((!bitmap_bit_p (&seen_in_insn, regno))
/* If the def is to only part of the reg, it does
not kill the other defs that reach here. */
&& (!(DF_REF_FLAGS (def) &
{
if (n_defs > DF_SPARSE_THRESHOLD)
{
- bitmap_set_bit (bb_info->sparse_kill, regno);
- bitmap_clear_range(bb_info->gen, begin, n_defs);
+ bitmap_set_bit (&bb_info->sparse_kill, regno);
+ bitmap_clear_range(&bb_info->gen, begin, n_defs);
}
else
{
- bitmap_set_range (bb_info->kill, begin, n_defs);
- bitmap_clear_range (bb_info->gen, begin, n_defs);
+ bitmap_set_range (&bb_info->kill, begin, n_defs);
+ bitmap_clear_range (&bb_info->gen, begin, n_defs);
}
}
- bitmap_set_bit (seen_in_insn, regno);
+ bitmap_set_bit (&seen_in_insn, regno);
/* All defs for regno in the instruction may be put into
the gen set. */
if (!(DF_REF_FLAGS (def)
& (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER)))
- bitmap_set_bit (bb_info->gen, DF_REF_ID (def));
+ bitmap_set_bit (&bb_info->gen, DF_REF_ID (def));
}
}
}
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
rtx insn;
- bitmap_clear (seen_in_block);
- bitmap_clear (seen_in_insn);
+ bitmap_clear (&seen_in_block);
+ bitmap_clear (&seen_in_insn);
/* Artificials are only hard regs. */
if (!(df->changeable_flags & DF_NO_HARD_REGS))
result and another def for the clobber. If only one vector
is used and the clobber goes first, the result will be
lost. */
- bitmap_ior_into (seen_in_block, seen_in_insn);
- bitmap_clear (seen_in_insn);
+ bitmap_ior_into (&seen_in_block, &seen_in_insn);
+ bitmap_clear (&seen_in_insn);
}
/* Process the artificial defs at the top of the block last since we
unsigned int regno;
struct df_rd_problem_data *problem_data
= (struct df_rd_problem_data *) df_rd->problem_data;
- bitmap sparse_invalidated = problem_data->sparse_invalidated_by_call;
- bitmap dense_invalidated = problem_data->dense_invalidated_by_call;
+ bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
+ bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
- seen_in_block = BITMAP_ALLOC (&df_bitmap_obstack);
- seen_in_insn = BITMAP_ALLOC (&df_bitmap_obstack);
+ bitmap_initialize (&seen_in_block, &df_bitmap_obstack);
+ bitmap_initialize (&seen_in_insn, &df_bitmap_obstack);
df_maybe_reorganize_def_refs (DF_REF_ORDER_BY_REG);
DF_DEFS_COUNT (regno));
}
- BITMAP_FREE (seen_in_block);
- BITMAP_FREE (seen_in_insn);
+ bitmap_clear (&seen_in_block);
+ bitmap_clear (&seen_in_insn);
}
{
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
- bitmap_copy (bb_info->out, bb_info->gen);
- bitmap_clear (bb_info->in);
+ bitmap_copy (&bb_info->out, &bb_info->gen);
+ bitmap_clear (&bb_info->in);
}
}
/* In of target gets or of out of source. */
-static void
+static bool
df_rd_confluence_n (edge e)
{
- bitmap op1 = df_rd_get_bb_info (e->dest->index)->in;
- bitmap op2 = df_rd_get_bb_info (e->src->index)->out;
+ bitmap op1 = &df_rd_get_bb_info (e->dest->index)->in;
+ bitmap op2 = &df_rd_get_bb_info (e->src->index)->out;
+ bool changed = false;
if (e->flags & EDGE_FAKE)
- return;
+ return false;
if (e->flags & EDGE_EH)
{
struct df_rd_problem_data *problem_data
= (struct df_rd_problem_data *) df_rd->problem_data;
- bitmap sparse_invalidated = problem_data->sparse_invalidated_by_call;
- bitmap dense_invalidated = problem_data->dense_invalidated_by_call;
+ bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
+ bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
bitmap_iterator bi;
unsigned int regno;
- bitmap tmp = BITMAP_ALLOC (&df_bitmap_obstack);
+ bitmap_head tmp;
- bitmap_copy (tmp, op2);
- bitmap_and_compl_into (tmp, dense_invalidated);
+ bitmap_initialize (&tmp, &df_bitmap_obstack);
+ bitmap_copy (&tmp, op2);
+ bitmap_and_compl_into (&tmp, dense_invalidated);
EXECUTE_IF_SET_IN_BITMAP (sparse_invalidated, 0, regno, bi)
{
- bitmap_clear_range (tmp,
+ bitmap_clear_range (&tmp,
DF_DEFS_BEGIN (regno),
DF_DEFS_COUNT (regno));
}
- bitmap_ior_into (op1, tmp);
- BITMAP_FREE (tmp);
+ changed |= bitmap_ior_into (op1, &tmp);
+ bitmap_clear (&tmp);
+ return changed;
}
else
- bitmap_ior_into (op1, op2);
+ return bitmap_ior_into (op1, op2);
}
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
unsigned int regno;
bitmap_iterator bi;
- bitmap in = bb_info->in;
- bitmap out = bb_info->out;
- bitmap gen = bb_info->gen;
- bitmap kill = bb_info->kill;
- bitmap sparse_kill = bb_info->sparse_kill;
+ bitmap in = &bb_info->in;
+ bitmap out = &bb_info->out;
+ bitmap gen = &bb_info->gen;
+ bitmap kill = &bb_info->kill;
+ bitmap sparse_kill = &bb_info->sparse_kill;
if (bitmap_empty_p (sparse_kill))
return bitmap_ior_and_compl (out, gen, in, kill);
{
struct df_rd_problem_data *problem_data;
bool changed = false;
- bitmap tmp;
+ bitmap_head tmp;
/* Note that TMP is _not_ a temporary bitmap if we end up replacing
OUT with TMP. Therefore, allocate TMP in the RD bitmaps obstack. */
problem_data = (struct df_rd_problem_data *) df_rd->problem_data;
- tmp = BITMAP_ALLOC (&problem_data->rd_bitmaps);
+ bitmap_initialize (&tmp, &problem_data->rd_bitmaps);
- bitmap_copy (tmp, in);
+ bitmap_copy (&tmp, in);
EXECUTE_IF_SET_IN_BITMAP (sparse_kill, 0, regno, bi)
{
- bitmap_clear_range (tmp,
+ bitmap_clear_range (&tmp,
DF_DEFS_BEGIN (regno),
DF_DEFS_COUNT (regno));
}
- bitmap_and_compl_into (tmp, kill);
- bitmap_ior_into (tmp, gen);
- changed = !bitmap_equal_p (tmp, out);
+ bitmap_and_compl_into (&tmp, kill);
+ bitmap_ior_into (&tmp, gen);
+ changed = !bitmap_equal_p (&tmp, out);
if (changed)
{
- BITMAP_FREE (out);
+ bitmap_clear (out);
bb_info->out = tmp;
}
else
- BITMAP_FREE (tmp);
+ bitmap_clear (&tmp);
return changed;
}
}
if (problem_data)
{
- free_alloc_pool (df_rd->block_pool);
bitmap_obstack_release (&problem_data->rd_bitmaps);
df_rd->block_info_size = 0;
free (df_rd->block_info);
+ df_rd->block_info = NULL;
free (df_rd->problem_data);
}
free (df_rd);
fprintf (file, ";; Reaching defs:\n\n");
fprintf (file, " sparse invalidated \t");
- dump_bitmap (file, problem_data->sparse_invalidated_by_call);
+ dump_bitmap (file, &problem_data->sparse_invalidated_by_call);
fprintf (file, " dense invalidated \t");
- dump_bitmap (file, problem_data->dense_invalidated_by_call);
+ dump_bitmap (file, &problem_data->dense_invalidated_by_call);
for (regno = 0; regno < m; regno++)
if (DF_DEFS_COUNT (regno))
df_rd_top_dump (basic_block bb, FILE *file)
{
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
- if (!bb_info || !bb_info->in)
+ if (!bb_info)
return;
- fprintf (file, ";; rd in \t(%d)\n", (int) bitmap_count_bits (bb_info->in));
- dump_bitmap (file, bb_info->in);
- fprintf (file, ";; rd gen \t(%d)\n", (int) bitmap_count_bits (bb_info->gen));
- dump_bitmap (file, bb_info->gen);
- fprintf (file, ";; rd kill\t(%d)\n", (int) bitmap_count_bits (bb_info->kill));
- dump_bitmap (file, bb_info->kill);
+ fprintf (file, ";; rd in \t(%d)\n", (int) bitmap_count_bits (&bb_info->in));
+ dump_bitmap (file, &bb_info->in);
+ fprintf (file, ";; rd gen \t(%d)\n", (int) bitmap_count_bits (&bb_info->gen));
+ dump_bitmap (file, &bb_info->gen);
+ fprintf (file, ";; rd kill\t(%d)\n", (int) bitmap_count_bits (&bb_info->kill));
+ dump_bitmap (file, &bb_info->kill);
}
df_rd_bottom_dump (basic_block bb, FILE *file)
{
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
- if (!bb_info || !bb_info->out)
+ if (!bb_info)
return;
- fprintf (file, ";; rd out \t(%d)\n", (int) bitmap_count_bits (bb_info->out));
- dump_bitmap (file, bb_info->out);
+ fprintf (file, ";; rd out \t(%d)\n", (int) bitmap_count_bits (&bb_info->out));
+ dump_bitmap (file, &bb_info->out);
}
/* All of the information associated with every instance of the problem. */
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
+ sizeof (struct df_rd_bb_info),/* Size of entry of block_info array. */
TV_DF_RD, /* Timing variable. */
true /* Reset blocks on dropping out of blocks_to_analyze. */
};
/* Private data used to verify the solution for this problem. */
struct df_lr_problem_data
{
- bitmap *in;
- bitmap *out;
+ bitmap_head *in;
+ bitmap_head *out;
+ /* An obstack for the bitmaps we need for this problem. */
+ bitmap_obstack lr_bitmaps;
};
-
-/* Set basic block info. */
-
-static void
-df_lr_set_bb_info (unsigned int index,
- struct df_lr_bb_info *bb_info)
-{
- gcc_assert (df_lr);
- gcc_assert (index < df_lr->block_info_size);
- df_lr->block_info[index] = bb_info;
-}
-
-
/* Free basic block info. */
static void
struct df_lr_bb_info *bb_info = (struct df_lr_bb_info *) vbb_info;
if (bb_info)
{
- BITMAP_FREE (bb_info->use);
- BITMAP_FREE (bb_info->def);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- pool_free (df_lr->block_pool, bb_info);
+ bitmap_clear (&bb_info->use);
+ bitmap_clear (&bb_info->def);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
{
unsigned int bb_index;
bitmap_iterator bi;
-
- if (!df_lr->block_pool)
- df_lr->block_pool = create_alloc_pool ("df_lr_block pool",
- sizeof (struct df_lr_bb_info), 50);
+ struct df_lr_problem_data *problem_data;
df_grow_bb_info (df_lr);
+ if (df_lr->problem_data)
+ problem_data = (struct df_lr_problem_data *) df_lr->problem_data;
+ else
+ {
+ problem_data = XNEW (struct df_lr_problem_data);
+ df_lr->problem_data = problem_data;
+
+ problem_data->out = NULL;
+ problem_data->in = NULL;
+ bitmap_obstack_initialize (&problem_data->lr_bitmaps);
+ }
EXECUTE_IF_SET_IN_BITMAP (df_lr->out_of_date_transfer_functions, 0, bb_index, bi)
{
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
- if (bb_info)
+
+ /* When bitmaps are already initialized, just clear them. */
+ if (bb_info->use.obstack)
{
- bitmap_clear (bb_info->def);
- bitmap_clear (bb_info->use);
+ bitmap_clear (&bb_info->def);
+ bitmap_clear (&bb_info->use);
}
else
{
- bb_info = (struct df_lr_bb_info *) pool_alloc (df_lr->block_pool);
- df_lr_set_bb_info (bb_index, bb_info);
- bb_info->use = BITMAP_ALLOC (NULL);
- bb_info->def = BITMAP_ALLOC (NULL);
- bb_info->in = BITMAP_ALLOC (NULL);
- bb_info->out = BITMAP_ALLOC (NULL);
+ bitmap_initialize (&bb_info->use, &problem_data->lr_bitmaps);
+ bitmap_initialize (&bb_info->def, &problem_data->lr_bitmaps);
+ bitmap_initialize (&bb_info->in, &problem_data->lr_bitmaps);
+ bitmap_initialize (&bb_info->out, &problem_data->lr_bitmaps);
}
}
{
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
gcc_assert (bb_info);
- bitmap_clear (bb_info->in);
- bitmap_clear (bb_info->out);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
{
unsigned int dregno = DF_REF_REGNO (def);
- bitmap_set_bit (bb_info->def, dregno);
- bitmap_clear_bit (bb_info->use, dregno);
+ bitmap_set_bit (&bb_info->def, dregno);
+ bitmap_clear_bit (&bb_info->use, dregno);
}
}
df_ref use = *use_rec;
/* Add use to set of uses in this BB. */
if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
- bitmap_set_bit (bb_info->use, DF_REF_REGNO (use));
+ bitmap_set_bit (&bb_info->use, DF_REF_REGNO (use));
}
FOR_BB_INSNS_REVERSE (bb, insn)
if (!(DF_REF_FLAGS (def) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
{
unsigned int dregno = DF_REF_REGNO (def);
- bitmap_set_bit (bb_info->def, dregno);
- bitmap_clear_bit (bb_info->use, dregno);
+ bitmap_set_bit (&bb_info->def, dregno);
+ bitmap_clear_bit (&bb_info->use, dregno);
}
}
{
df_ref use = *use_rec;
/* Add use to set of uses in this BB. */
- bitmap_set_bit (bb_info->use, DF_REF_REGNO (use));
+ bitmap_set_bit (&bb_info->use, DF_REF_REGNO (use));
}
}
if (DF_REF_FLAGS (def) & DF_REF_AT_TOP)
{
unsigned int dregno = DF_REF_REGNO (def);
- bitmap_set_bit (bb_info->def, dregno);
- bitmap_clear_bit (bb_info->use, dregno);
+ bitmap_set_bit (&bb_info->def, dregno);
+ bitmap_clear_bit (&bb_info->use, dregno);
}
}
df_ref use = *use_rec;
/* Add use to set of uses in this BB. */
if (DF_REF_FLAGS (use) & DF_REF_AT_TOP)
- bitmap_set_bit (bb_info->use, DF_REF_REGNO (use));
+ bitmap_set_bit (&bb_info->use, DF_REF_REGNO (use));
}
#endif
unsigned int bb_index;
bitmap_iterator bi;
- bitmap_clear (df->hardware_regs_used);
+ bitmap_clear (&df->hardware_regs_used);
/* The all-important stack pointer must always be live. */
- bitmap_set_bit (df->hardware_regs_used, STACK_POINTER_REGNUM);
+ bitmap_set_bit (&df->hardware_regs_used, STACK_POINTER_REGNUM);
/* Before reload, there are a few registers that must be forced
live everywhere -- which might not already be the case for
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);
+ bitmap_set_bit (&df->hardware_regs_used, FRAME_POINTER_REGNUM);
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
/* Pseudos with argument area equivalences may require
reloading via the argument pointer. */
if (fixed_regs[ARG_POINTER_REGNUM])
- bitmap_set_bit (df->hardware_regs_used, ARG_POINTER_REGNUM);
+ bitmap_set_bit (&df->hardware_regs_used, ARG_POINTER_REGNUM);
#endif
/* 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)
/* The exit block is special for this problem and its bits are
computed from thin air. */
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (EXIT_BLOCK);
- bitmap_copy (bb_info->use, df->exit_block_uses);
+ bitmap_copy (&bb_info->use, df->exit_block_uses);
}
else
df_lr_bb_local_compute (bb_index);
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
- bitmap_copy (bb_info->in, bb_info->use);
- bitmap_clear (bb_info->out);
+ bitmap_copy (&bb_info->in, &bb_info->use);
+ bitmap_clear (&bb_info->out);
}
}
static void
df_lr_confluence_0 (basic_block bb)
{
- bitmap op1 = df_lr_get_bb_info (bb->index)->out;
+ bitmap op1 = &df_lr_get_bb_info (bb->index)->out;
if (bb != EXIT_BLOCK_PTR)
- bitmap_copy (op1, df->hardware_regs_used);
+ bitmap_copy (op1, &df->hardware_regs_used);
}
/* Confluence function that ignores fake edges. */
-static void
+static bool
df_lr_confluence_n (edge e)
{
- bitmap op1 = df_lr_get_bb_info (e->src->index)->out;
- bitmap op2 = df_lr_get_bb_info (e->dest->index)->in;
+ bitmap op1 = &df_lr_get_bb_info (e->src->index)->out;
+ bitmap op2 = &df_lr_get_bb_info (e->dest->index)->in;
+ bool changed = false;
/* 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)
- bitmap_ior_and_compl_into (op1, op2, regs_invalidated_by_call_regset);
+ changed = bitmap_ior_and_compl_into (op1, op2, regs_invalidated_by_call_regset);
else
- bitmap_ior_into (op1, op2);
+ changed = bitmap_ior_into (op1, op2);
- bitmap_ior_into (op1, df->hardware_regs_used);
+ changed |= bitmap_ior_into (op1, &df->hardware_regs_used);
+ return changed;
}
df_lr_transfer_function (int bb_index)
{
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
- bitmap in = bb_info->in;
- bitmap out = bb_info->out;
- bitmap use = bb_info->use;
- bitmap def = bb_info->def;
+ bitmap in = &bb_info->in;
+ bitmap out = &bb_info->out;
+ bitmap use = &bb_info->use;
+ bitmap def = &bb_info->def;
return bitmap_ior_and_compl (in, use, out, def);
}
static void
df_lr_free (void)
{
+ struct df_lr_problem_data *problem_data
+ = (struct df_lr_problem_data *) df_lr->problem_data;
if (df_lr->block_info)
{
- unsigned int i;
- for (i = 0; i < df_lr->block_info_size; i++)
- {
- struct df_lr_bb_info *bb_info = df_lr_get_bb_info (i);
- if (bb_info)
- {
- BITMAP_FREE (bb_info->use);
- BITMAP_FREE (bb_info->def);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- }
- }
- free_alloc_pool (df_lr->block_pool);
df_lr->block_info_size = 0;
free (df_lr->block_info);
+ df_lr->block_info = NULL;
+ bitmap_obstack_release (&problem_data->lr_bitmaps);
+ free (df_lr->problem_data);
+ df_lr->problem_data = NULL;
}
BITMAP_FREE (df_lr->out_of_date_transfer_functions);
{
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
struct df_lr_problem_data *problem_data;
- if (!bb_info || !bb_info->in)
+ if (!bb_info)
return;
fprintf (file, ";; lr in \t");
- df_print_regset (file, bb_info->in);
+ df_print_regset (file, &bb_info->in);
if (df_lr->problem_data)
{
problem_data = (struct df_lr_problem_data *)df_lr->problem_data;
- fprintf (file, ";; old in \t");
- df_print_regset (file, problem_data->in[bb->index]);
+ if (problem_data->in)
+ {
+ fprintf (file, ";; old in \t");
+ df_print_regset (file, &problem_data->in[bb->index]);
+ }
}
fprintf (file, ";; lr use \t");
- df_print_regset (file, bb_info->use);
+ df_print_regset (file, &bb_info->use);
fprintf (file, ";; lr def \t");
- df_print_regset (file, bb_info->def);
+ df_print_regset (file, &bb_info->def);
}
{
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
struct df_lr_problem_data *problem_data;
- if (!bb_info || !bb_info->out)
+ if (!bb_info)
return;
fprintf (file, ";; lr out \t");
- df_print_regset (file, bb_info->out);
+ df_print_regset (file, &bb_info->out);
if (df_lr->problem_data)
{
problem_data = (struct df_lr_problem_data *)df_lr->problem_data;
- fprintf (file, ";; old out \t");
- df_print_regset (file, problem_data->out[bb->index]);
+ if (problem_data->out)
+ {
+ fprintf (file, ";; old out \t");
+ df_print_regset (file, &problem_data->out[bb->index]);
+ }
}
}
basic_block bb;
struct df_lr_problem_data *problem_data;
if (df_lr->solutions_dirty)
- {
- df_lr->problem_data = NULL;
- return;
- }
+ return;
/* Set it true so that the solution is recomputed. */
df_lr->solutions_dirty = true;
- problem_data = XNEW (struct df_lr_problem_data);
- df_lr->problem_data = problem_data;
- problem_data->in = XNEWVEC (bitmap, last_basic_block);
- problem_data->out = XNEWVEC (bitmap, last_basic_block);
+ problem_data = (struct df_lr_problem_data *)df_lr->problem_data;
+ problem_data->in = XNEWVEC (bitmap_head, last_basic_block);
+ problem_data->out = XNEWVEC (bitmap_head, last_basic_block);
FOR_ALL_BB (bb)
{
- problem_data->in[bb->index] = BITMAP_ALLOC (NULL);
- problem_data->out[bb->index] = BITMAP_ALLOC (NULL);
- bitmap_copy (problem_data->in[bb->index], DF_LR_IN (bb));
- bitmap_copy (problem_data->out[bb->index], DF_LR_OUT (bb));
+ bitmap_initialize (&problem_data->in[bb->index], &problem_data->lr_bitmaps);
+ bitmap_initialize (&problem_data->out[bb->index], &problem_data->lr_bitmaps);
+ bitmap_copy (&problem_data->in[bb->index], DF_LR_IN (bb));
+ bitmap_copy (&problem_data->out[bb->index], DF_LR_OUT (bb));
}
}
struct df_lr_problem_data *problem_data;
basic_block bb;
- if (df_lr->problem_data == NULL)
- return;
-
problem_data = (struct df_lr_problem_data *)df_lr->problem_data;
+ if (!problem_data->out)
+ return;
+
if (df_lr->solutions_dirty)
/* Do not check if the solution is still dirty. See the comment
in df_lr_finalize for details. */
else
FOR_ALL_BB (bb)
{
- if ((!bitmap_equal_p (problem_data->in[bb->index], DF_LR_IN (bb)))
- || (!bitmap_equal_p (problem_data->out[bb->index], DF_LR_OUT (bb))))
+ if ((!bitmap_equal_p (&problem_data->in[bb->index], DF_LR_IN (bb)))
+ || (!bitmap_equal_p (&problem_data->out[bb->index], DF_LR_OUT (bb))))
{
/*df_dump (stderr);*/
gcc_unreachable ();
if the comparison fails. */
FOR_ALL_BB (bb)
{
- BITMAP_FREE (problem_data->in[bb->index]);
- BITMAP_FREE (problem_data->out[bb->index]);
+ bitmap_clear (&problem_data->in[bb->index]);
+ bitmap_clear (&problem_data->out[bb->index]);
}
free (problem_data->in);
free (problem_data->out);
- free (problem_data);
- df_lr->problem_data = NULL;
+ problem_data->in = NULL;
+ problem_data->out = NULL;
}
df_lr_verify_solution_start,/* Incremental solution verify start. */
df_lr_verify_solution_end, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
+ sizeof (struct df_lr_bb_info),/* Size of entry of block_info array. */
TV_DF_LR, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
df_lr_verify_transfer_functions (void)
{
basic_block bb;
- bitmap saved_def;
- bitmap saved_use;
- bitmap saved_adef;
- bitmap saved_ause;
- bitmap all_blocks;
+ bitmap_head saved_def;
+ bitmap_head saved_use;
+ bitmap_head all_blocks;
if (!df)
return;
- saved_def = BITMAP_ALLOC (NULL);
- saved_use = BITMAP_ALLOC (NULL);
- saved_adef = BITMAP_ALLOC (NULL);
- saved_ause = BITMAP_ALLOC (NULL);
- all_blocks = BITMAP_ALLOC (NULL);
+ bitmap_initialize (&saved_def, &bitmap_default_obstack);
+ bitmap_initialize (&saved_use, &bitmap_default_obstack);
+ bitmap_initialize (&all_blocks, &bitmap_default_obstack);
FOR_ALL_BB (bb)
{
struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
- bitmap_set_bit (all_blocks, bb->index);
+ bitmap_set_bit (&all_blocks, bb->index);
if (bb_info)
{
if (!bitmap_bit_p (df_lr->out_of_date_transfer_functions,
bb->index))
{
- bitmap_copy (saved_def, bb_info->def);
- bitmap_copy (saved_use, bb_info->use);
- bitmap_clear (bb_info->def);
- bitmap_clear (bb_info->use);
+ bitmap_copy (&saved_def, &bb_info->def);
+ bitmap_copy (&saved_use, &bb_info->use);
+ bitmap_clear (&bb_info->def);
+ bitmap_clear (&bb_info->use);
df_lr_bb_local_compute (bb->index);
- gcc_assert (bitmap_equal_p (saved_def, bb_info->def));
- gcc_assert (bitmap_equal_p (saved_use, bb_info->use));
+ gcc_assert (bitmap_equal_p (&saved_def, &bb_info->def));
+ gcc_assert (bitmap_equal_p (&saved_use, &bb_info->use));
}
}
else
/* Make sure there are no dirty bits in blocks that have been deleted. */
gcc_assert (!bitmap_intersect_compl_p (df_lr->out_of_date_transfer_functions,
- all_blocks));
+ &all_blocks));
- BITMAP_FREE (saved_def);
- BITMAP_FREE (saved_use);
- BITMAP_FREE (saved_adef);
- BITMAP_FREE (saved_ause);
- BITMAP_FREE (all_blocks);
+ bitmap_clear (&saved_def);
+ bitmap_clear (&saved_use);
+ bitmap_clear (&all_blocks);
}
/* Private data used to verify the solution for this problem. */
struct df_live_problem_data
{
- bitmap *in;
- bitmap *out;
+ bitmap_head *in;
+ bitmap_head *out;
+ /* An obstack for the bitmaps we need for this problem. */
+ bitmap_obstack live_bitmaps;
};
/* Scratch var used by transfer functions. This is used to implement
an optimization to reduce the amount of space used to compute the
combined lr and live analysis. */
-static bitmap df_live_scratch;
-
-/* Set basic block info. */
-
-static void
-df_live_set_bb_info (unsigned int index,
- struct df_live_bb_info *bb_info)
-{
- gcc_assert (df_live);
- gcc_assert (index < df_live->block_info_size);
- df_live->block_info[index] = bb_info;
-}
+static bitmap_head df_live_scratch;
/* Free basic block info. */
struct df_live_bb_info *bb_info = (struct df_live_bb_info *) vbb_info;
if (bb_info)
{
- BITMAP_FREE (bb_info->gen);
- BITMAP_FREE (bb_info->kill);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- pool_free (df_live->block_pool, bb_info);
+ bitmap_clear (&bb_info->gen);
+ bitmap_clear (&bb_info->kill);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
{
unsigned int bb_index;
bitmap_iterator bi;
+ struct df_live_problem_data *problem_data;
- if (!df_live->block_pool)
- df_live->block_pool = create_alloc_pool ("df_live_block pool",
- sizeof (struct df_live_bb_info), 100);
- if (!df_live_scratch)
- df_live_scratch = BITMAP_ALLOC (NULL);
+ if (df_live->problem_data)
+ problem_data = (struct df_live_problem_data *) df_live->problem_data;
+ else
+ {
+ problem_data = XNEW (struct df_live_problem_data);
+ df_live->problem_data = problem_data;
+
+ problem_data->out = NULL;
+ problem_data->in = NULL;
+ bitmap_obstack_initialize (&problem_data->live_bitmaps);
+ bitmap_initialize (&df_live_scratch, &problem_data->live_bitmaps);
+ }
df_grow_bb_info (df_live);
EXECUTE_IF_SET_IN_BITMAP (df_live->out_of_date_transfer_functions, 0, bb_index, bi)
{
struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
- if (bb_info)
+
+ /* When bitmaps are already initialized, just clear them. */
+ if (bb_info->kill.obstack)
{
- bitmap_clear (bb_info->kill);
- bitmap_clear (bb_info->gen);
+ bitmap_clear (&bb_info->kill);
+ bitmap_clear (&bb_info->gen);
}
else
{
- bb_info = (struct df_live_bb_info *) pool_alloc (df_live->block_pool);
- df_live_set_bb_info (bb_index, bb_info);
- bb_info->kill = BITMAP_ALLOC (NULL);
- bb_info->gen = BITMAP_ALLOC (NULL);
- bb_info->in = BITMAP_ALLOC (NULL);
- bb_info->out = BITMAP_ALLOC (NULL);
+ bitmap_initialize (&bb_info->kill, &problem_data->live_bitmaps);
+ bitmap_initialize (&bb_info->gen, &problem_data->live_bitmaps);
+ bitmap_initialize (&bb_info->in, &problem_data->live_bitmaps);
+ bitmap_initialize (&bb_info->out, &problem_data->live_bitmaps);
}
}
df_live->optional_p = (optimize <= 1);
{
struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
gcc_assert (bb_info);
- bitmap_clear (bb_info->in);
- bitmap_clear (bb_info->out);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
DF_REF_PARTIAL | DF_REF_CONDITIONAL))
/* All partial or conditional def
seen are included in the gen set. */
- bitmap_set_bit (bb_info->gen, regno);
+ bitmap_set_bit (&bb_info->gen, regno);
else if (DF_REF_FLAGS_IS_SET (def, DF_REF_MUST_CLOBBER))
/* Only must clobbers for the entire reg destroy the
value. */
- bitmap_set_bit (bb_info->kill, regno);
+ bitmap_set_bit (&bb_info->kill, regno);
else if (! DF_REF_FLAGS_IS_SET (def, DF_REF_MAY_CLOBBER))
- bitmap_set_bit (bb_info->gen, regno);
+ bitmap_set_bit (&bb_info->gen, regno);
}
}
for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
{
df_ref def = *def_rec;
- bitmap_set_bit (bb_info->gen, DF_REF_REGNO (def));
+ bitmap_set_bit (&bb_info->gen, DF_REF_REGNO (def));
}
}
/* No register may reach a location where it is not used. Thus
we trim the rr result to the places where it is used. */
- bitmap_and (bb_info->out, bb_info->gen, bb_lr_info->out);
- bitmap_clear (bb_info->in);
+ bitmap_and (&bb_info->out, &bb_info->gen, &bb_lr_info->out);
+ bitmap_clear (&bb_info->in);
}
}
/* Forward confluence function that ignores fake edges. */
-static void
+static bool
df_live_confluence_n (edge e)
{
- bitmap op1 = df_live_get_bb_info (e->dest->index)->in;
- bitmap op2 = df_live_get_bb_info (e->src->index)->out;
+ bitmap op1 = &df_live_get_bb_info (e->dest->index)->in;
+ bitmap op2 = &df_live_get_bb_info (e->src->index)->out;
if (e->flags & EDGE_FAKE)
- return;
+ return false;
- bitmap_ior_into (op1, op2);
+ return bitmap_ior_into (op1, op2);
}
{
struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
struct df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
- bitmap in = bb_info->in;
- bitmap out = bb_info->out;
- bitmap gen = bb_info->gen;
- bitmap kill = bb_info->kill;
+ bitmap in = &bb_info->in;
+ bitmap out = &bb_info->out;
+ bitmap gen = &bb_info->gen;
+ bitmap kill = &bb_info->kill;
/* We need to use a scratch set here so that the value returned from this
function invocation properly reflects whether the sets changed in a
significant way; i.e. not just because the lr set was anded in. */
- bitmap_and (df_live_scratch, gen, bb_lr_info->out);
+ bitmap_and (&df_live_scratch, gen, &bb_lr_info->out);
/* No register may reach a location where it is not used. Thus
we trim the rr result to the places where it is used. */
- bitmap_and_into (in, bb_lr_info->in);
+ bitmap_and_into (in, &bb_lr_info->in);
- return bitmap_ior_and_compl (out, df_live_scratch, in, kill);
+ return bitmap_ior_and_compl (out, &df_live_scratch, in, kill);
}
/* No register may reach a location where it is not used. Thus
we trim the rr result to the places where it is used. */
- bitmap_and_into (bb_live_info->in, bb_lr_info->in);
- bitmap_and_into (bb_live_info->out, bb_lr_info->out);
+ bitmap_and_into (&bb_live_info->in, &bb_lr_info->in);
+ bitmap_and_into (&bb_live_info->out, &bb_lr_info->out);
}
df_live->solutions_dirty = false;
static void
df_live_free (void)
{
+ struct df_live_problem_data *problem_data
+ = (struct df_live_problem_data *) df_live->problem_data;
if (df_live->block_info)
{
- unsigned int i;
-
- for (i = 0; i < df_live->block_info_size; i++)
- {
- struct df_live_bb_info *bb_info = df_live_get_bb_info (i);
- if (bb_info)
- {
- BITMAP_FREE (bb_info->gen);
- BITMAP_FREE (bb_info->kill);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- }
- }
-
- free_alloc_pool (df_live->block_pool);
df_live->block_info_size = 0;
free (df_live->block_info);
-
- if (df_live_scratch)
- BITMAP_FREE (df_live_scratch);
+ df_live->block_info = NULL;
+ bitmap_clear (&df_live_scratch);
+ bitmap_obstack_release (&problem_data->live_bitmaps);
+ free (problem_data);
+ df_live->problem_data = NULL;
}
BITMAP_FREE (df_live->out_of_date_transfer_functions);
free (df_live);
struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
struct df_live_problem_data *problem_data;
- if (!bb_info || !bb_info->in)
+ if (!bb_info)
return;
fprintf (file, ";; live in \t");
- df_print_regset (file, bb_info->in);
+ df_print_regset (file, &bb_info->in);
if (df_live->problem_data)
{
problem_data = (struct df_live_problem_data *)df_live->problem_data;
- fprintf (file, ";; old in \t");
- df_print_regset (file, problem_data->in[bb->index]);
+ if (problem_data->in)
+ {
+ fprintf (file, ";; old in \t");
+ df_print_regset (file, &problem_data->in[bb->index]);
+ }
}
fprintf (file, ";; live gen \t");
- df_print_regset (file, bb_info->gen);
+ df_print_regset (file, &bb_info->gen);
fprintf (file, ";; live kill\t");
- df_print_regset (file, bb_info->kill);
+ df_print_regset (file, &bb_info->kill);
}
struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
struct df_live_problem_data *problem_data;
- if (!bb_info || !bb_info->out)
+ if (!bb_info)
return;
fprintf (file, ";; live out \t");
- df_print_regset (file, bb_info->out);
+ df_print_regset (file, &bb_info->out);
if (df_live->problem_data)
{
problem_data = (struct df_live_problem_data *)df_live->problem_data;
- fprintf (file, ";; old out \t");
- df_print_regset (file, problem_data->out[bb->index]);
+ if (problem_data->out)
+ {
+ fprintf (file, ";; old out \t");
+ df_print_regset (file, &problem_data->out[bb->index]);
+ }
}
}
basic_block bb;
struct df_live_problem_data *problem_data;
if (df_live->solutions_dirty)
- {
- df_live->problem_data = NULL;
- return;
- }
+ return;
/* Set it true so that the solution is recomputed. */
df_live->solutions_dirty = true;
- problem_data = XNEW (struct df_live_problem_data);
- df_live->problem_data = problem_data;
- problem_data->in = XNEWVEC (bitmap, last_basic_block);
- problem_data->out = XNEWVEC (bitmap, last_basic_block);
+ problem_data = (struct df_live_problem_data *)df_live->problem_data;
+ problem_data->in = XNEWVEC (bitmap_head, last_basic_block);
+ problem_data->out = XNEWVEC (bitmap_head, last_basic_block);
FOR_ALL_BB (bb)
{
- problem_data->in[bb->index] = BITMAP_ALLOC (NULL);
- problem_data->out[bb->index] = BITMAP_ALLOC (NULL);
- bitmap_copy (problem_data->in[bb->index], DF_LIVE_IN (bb));
- bitmap_copy (problem_data->out[bb->index], DF_LIVE_OUT (bb));
+ bitmap_initialize (&problem_data->in[bb->index], &problem_data->live_bitmaps);
+ bitmap_initialize (&problem_data->out[bb->index], &problem_data->live_bitmaps);
+ bitmap_copy (&problem_data->in[bb->index], DF_LIVE_IN (bb));
+ bitmap_copy (&problem_data->out[bb->index], DF_LIVE_OUT (bb));
}
}
struct df_live_problem_data *problem_data;
basic_block bb;
- if (df_live->problem_data == NULL)
- return;
-
problem_data = (struct df_live_problem_data *)df_live->problem_data;
+ if (!problem_data->out)
+ return;
FOR_ALL_BB (bb)
{
- if ((!bitmap_equal_p (problem_data->in[bb->index], DF_LIVE_IN (bb)))
- || (!bitmap_equal_p (problem_data->out[bb->index], DF_LIVE_OUT (bb))))
+ if ((!bitmap_equal_p (&problem_data->in[bb->index], DF_LIVE_IN (bb)))
+ || (!bitmap_equal_p (&problem_data->out[bb->index], DF_LIVE_OUT (bb))))
{
/*df_dump (stderr);*/
gcc_unreachable ();
if the comparison fails. */
FOR_ALL_BB (bb)
{
- BITMAP_FREE (problem_data->in[bb->index]);
- BITMAP_FREE (problem_data->out[bb->index]);
+ bitmap_clear (&problem_data->in[bb->index]);
+ bitmap_clear (&problem_data->out[bb->index]);
}
free (problem_data->in);
df_live_verify_solution_start,/* Incremental solution verify start. */
df_live_verify_solution_end, /* Incremental solution verify end. */
&problem_LR, /* Dependent problem. */
+ sizeof (struct df_live_bb_info),/* Size of entry of block_info array. */
TV_DF_LIVE, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
df_live_verify_transfer_functions (void)
{
basic_block bb;
- bitmap saved_gen;
- bitmap saved_kill;
- bitmap all_blocks;
+ bitmap_head saved_gen;
+ bitmap_head saved_kill;
+ bitmap_head all_blocks;
if (!df)
return;
- saved_gen = BITMAP_ALLOC (NULL);
- saved_kill = BITMAP_ALLOC (NULL);
- all_blocks = BITMAP_ALLOC (NULL);
+ bitmap_initialize (&saved_gen, &bitmap_default_obstack);
+ bitmap_initialize (&saved_kill, &bitmap_default_obstack);
+ bitmap_initialize (&all_blocks, &bitmap_default_obstack);
df_grow_insn_info ();
FOR_ALL_BB (bb)
{
struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
- bitmap_set_bit (all_blocks, bb->index);
+ bitmap_set_bit (&all_blocks, bb->index);
if (bb_info)
{
if (!bitmap_bit_p (df_live->out_of_date_transfer_functions,
bb->index))
{
- bitmap_copy (saved_gen, bb_info->gen);
- bitmap_copy (saved_kill, bb_info->kill);
- bitmap_clear (bb_info->gen);
- bitmap_clear (bb_info->kill);
+ bitmap_copy (&saved_gen, &bb_info->gen);
+ bitmap_copy (&saved_kill, &bb_info->kill);
+ bitmap_clear (&bb_info->gen);
+ bitmap_clear (&bb_info->kill);
df_live_bb_local_compute (bb->index);
- gcc_assert (bitmap_equal_p (saved_gen, bb_info->gen));
- gcc_assert (bitmap_equal_p (saved_kill, bb_info->kill));
+ gcc_assert (bitmap_equal_p (&saved_gen, &bb_info->gen));
+ gcc_assert (bitmap_equal_p (&saved_kill, &bb_info->kill));
}
}
else
/* Make sure there are no dirty bits in blocks that have been deleted. */
gcc_assert (!bitmap_intersect_compl_p (df_live->out_of_date_transfer_functions,
- all_blocks));
- BITMAP_FREE (saved_gen);
- BITMAP_FREE (saved_kill);
- BITMAP_FREE (all_blocks);
+ &all_blocks));
+ bitmap_clear (&saved_gen);
+ bitmap_clear (&saved_kill);
+ bitmap_clear (&all_blocks);
}
\f
/*----------------------------------------------------------------------------
basic_block bb = BASIC_BLOCK (bb_index);
struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
rtx insn;
- bitmap cpy = BITMAP_ALLOC (NULL);
+ bitmap_head cpy;
- bitmap_copy (cpy, bb_info->in);
+ bitmap_initialize (&cpy, &bitmap_default_obstack);
+ bitmap_copy (&cpy, &bb_info->in);
bitmap_set_bit (df_chain->out_of_date_transfer_functions, bb_index);
/* Since we are going forwards, process the artificial uses first
/* Artificials are only hard regs. */
if (!(df->changeable_flags & DF_NO_HARD_REGS))
- df_chain_create_bb_process_use (cpy,
+ df_chain_create_bb_process_use (&cpy,
df_get_artificial_uses (bb->index),
DF_REF_AT_TOP);
#endif
- df_rd_simulate_artificial_defs_at_top (bb, cpy);
+ df_rd_simulate_artificial_defs_at_top (bb, &cpy);
/* Process the regular instructions next. */
FOR_BB_INSNS (bb, insn)
/* First scan the uses and link them up with the defs that remain
in the cpy vector. */
- df_chain_create_bb_process_use (cpy, DF_INSN_UID_USES (uid), 0);
+ df_chain_create_bb_process_use (&cpy, DF_INSN_UID_USES (uid), 0);
if (df->changeable_flags & DF_EQ_NOTES)
- df_chain_create_bb_process_use (cpy, DF_INSN_UID_EQ_USES (uid), 0);
+ df_chain_create_bb_process_use (&cpy, DF_INSN_UID_EQ_USES (uid), 0);
/* Since we are going forwards, process the defs second. */
- df_rd_simulate_one_insn (bb, insn, cpy);
+ df_rd_simulate_one_insn (bb, insn, &cpy);
}
/* Create the chains for the artificial uses of the hard registers
at the end of the block. */
if (!(df->changeable_flags & DF_NO_HARD_REGS))
- df_chain_create_bb_process_use (cpy,
+ df_chain_create_bb_process_use (&cpy,
df_get_artificial_uses (bb->index),
0);
- BITMAP_FREE (cpy);
+ bitmap_clear (&cpy);
}
/* Create def-use chains from reaching use bitmaps for basic blocks
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
&problem_RD, /* Dependent problem. */
+ sizeof (struct df_scan_bb_info),/* Size of entry of block_info array. */
TV_DF_CHAIN, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
\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 invalidated_by_call;
- bitmap hardware_regs_used;
-
- /* Indexed by regno, this is true if there are subregs, extracts or
- strict_low_parts for this regno. */
- bitmap 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];
-}
-
-
-/* Set basic block info. */
-
-static void
-df_byte_lr_set_bb_info (unsigned int index,
- struct df_byte_lr_bb_info *bb_info)
-{
- gcc_assert (df_byte_lr);
- gcc_assert (index < df_byte_lr->block_info_size);
- df_byte_lr->block_info[index] = bb_info;
-}
-
-
/* 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_FREE (bb_info->use);
- BITMAP_FREE (bb_info->def);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- pool_free (df_byte_lr->block_pool, bb_info);
- }
-}
-
-
-/* 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]);
+ bitmap_clear (&bb_info->use);
+ bitmap_clear (&bb_info->def);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
-/* 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;
- if (!df_byte_lr->block_pool)
- df_byte_lr->block_pool = create_alloc_pool ("df_byte_lr_block pool",
- sizeof (struct df_byte_lr_bb_info), 50);
-
- 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);
- problem_data->hardware_regs_used = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps);
- problem_data->invalidated_by_call = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps);
- problem_data->needs_expansion = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps);
+ bitmap_obstack_initialize (&problem_data->word_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);
+ bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, bb->index);
- /* 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;
-
- problem_data->regno_len[regno] = len;
- index += len;
- }
+ 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);
- 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);
-
- 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);
- if (bb_info)
+ 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)
{
- bitmap_clear (bb_info->def);
- bitmap_clear (bb_info->use);
+ bitmap_clear (&bb_info->def);
+ bitmap_clear (&bb_info->use);
}
else
{
- bb_info = (struct df_byte_lr_bb_info *) pool_alloc (df_byte_lr->block_pool);
- df_byte_lr_set_bb_info (bb_index, bb_info);
- bb_info->use = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps);
- bb_info->def = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps);
- bb_info->in = BITMAP_ALLOC (&problem_data->byte_lr_bitmaps);
- bb_info->out = BITMAP_ALLOC (&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);
+ 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);
- }
- }
-
- /* 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);
+ df_word_lr_mark_ref (use, true, &bb_info->use);
}
}
-#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);
- bitmap_copy (bb_info->in, bb_info->use);
- bitmap_clear (bb_info->out);
+ 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 void
-df_byte_lr_confluence_n (edge e)
+static bool
+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;
-
- /* 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)
- bitmap_ior_and_compl_into (op1, op2, problem_data->invalidated_by_call);
- else
- bitmap_ior_into (op1, op2);
+ bitmap op1 = &df_word_lr_get_bb_info (e->src->index)->out;
+ bitmap op2 = &df_word_lr_get_bb_info (e->dest->index)->in;
- bitmap_ior_into (op1, problem_data->hardware_regs_used);
+ 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);
- bitmap in = bb_info->in;
- bitmap out = bb_info->out;
- bitmap use = bb_info->use;
- bitmap def = bb_info->def;
+ 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;
+ bitmap def = &bb_info->def;
return bitmap_ior_and_compl (in, use, out, def);
}
/* 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)
{
- free_alloc_pool (df_byte_lr->block_pool);
- df_byte_lr->block_info_size = 0;
- free (df_byte_lr->block_info);
+ 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);
- if (!bb_info || !bb_info->in)
+ 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);
- if (!bb_info || !bb_info->out)
+ 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. */
- TV_DF_BYTE_LR, /* Timing variable. */
+ NULL, /* Dependent problem. */
+ 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.
- ----------------------------------------------------------------------------*/
+\f
+/*----------------------------------------------------------------------------
+ This problem computes REG_DEAD and REG_UNUSED notes.
+ ----------------------------------------------------------------------------*/
static void
df_note_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
/* 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, rtx *old_dead_notes, rtx *old_unused_notes)
+df_kill_notes (rtx insn, bitmap live)
{
rtx *pprev = ®_NOTES (insn);
rtx link = *pprev;
- rtx dead = NULL;
- rtx unused = NULL;
while (link)
{
#ifdef REG_DEAD_DEBUGGING
df_print_note ("deleting: ", insn, link);
#endif
- XEXP (link, 1) = dead;
- dead = link;
+ free_EXPR_LIST_node (link);
*pprev = link = next;
}
break;
#ifdef REG_DEAD_DEBUGGING
df_print_note ("deleting: ", insn, link);
#endif
- XEXP (link, 1) = unused;
- unused = link;
+ free_EXPR_LIST_node (link);
*pprev = link = next;
}
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;
break;
}
}
-
- *old_dead_notes = dead;
- *old_unused_notes = unused;
}
-/* Set a NOTE_TYPE note for REG in INSN. Try to pull it from the OLD
- list, otherwise create a new one. */
+/* Set a NOTE_TYPE note for REG in INSN. */
-static inline rtx
-df_set_note (enum reg_note note_type, rtx insn, rtx old, rtx reg)
+static inline void
+df_set_note (enum reg_note note_type, rtx insn, rtx reg)
{
- rtx curr = old;
- rtx prev = NULL;
-
- gcc_assert (!DEBUG_INSN_P (insn));
-
- while (curr)
- if (XEXP (curr, 0) == reg)
- {
- if (prev)
- XEXP (prev, 1) = XEXP (curr, 1);
- else
- old = XEXP (curr, 1);
- XEXP (curr, 1) = REG_NOTES (insn);
- REG_NOTES (insn) = curr;
- return old;
- }
- else
- {
- prev = curr;
- curr = XEXP (curr, 1);
- }
-
- /* Did not find the note. */
+ gcc_checking_assert (!DEBUG_INSN_P (insn));
add_reg_note (insn, note_type, reg);
- return old;
}
/* A subroutine of df_set_unused_notes_for_mw, with a selection of its
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
instruction.
*/
-static rtx
-df_set_unused_notes_for_mw (rtx insn, rtx old, struct df_mw_hardreg *mws,
+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;
if (df_whole_mw_reg_unused_p (mws, live, artificial_uses))
{
unsigned int regno = mws->start_regno;
- old = df_set_note (REG_UNUSED, insn, old, mws->mw_reg);
+ 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));
if (!bitmap_bit_p (live, r)
&& !bitmap_bit_p (artificial_uses, r))
{
- old = df_set_note (REG_UNUSED, insn, old, regno_reg_rtx[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
}
bitmap_set_bit (do_not_gen, r);
}
- return old;
}
from being set if the instruction both reads and writes the
register. */
-static rtx
-df_set_dead_notes_for_mw (rtx insn, rtx old, struct df_mw_hardreg *mws,
+static void
+df_set_dead_notes_for_mw (rtx insn, struct df_mw_hardreg *mws,
bitmap live, bitmap do_not_gen,
bitmap artificial_uses, bool *added_notes_p)
{
if (is_debug)
{
*added_notes_p = true;
- return old;
+ return;
}
- old = df_set_note (REG_DEAD, insn, old, mws->mw_reg);
+ df_set_note (REG_DEAD, insn, mws->mw_reg);
#ifdef REG_DEAD_DEBUGGING
df_print_note ("adding 1: ", insn, REG_NOTES (insn));
#endif
if (is_debug)
{
*added_notes_p = true;
- return old;
+ return;
}
- old = df_set_note (REG_DEAD, insn, old, regno_reg_rtx[r]);
+ df_set_note (REG_DEAD, insn, regno_reg_rtx[r]);
#ifdef REG_DEAD_DEBUGGING
df_print_note ("adding 2: ", insn, REG_NOTES (insn));
#endif
}
}
- return old;
+ return;
}
/* Create a REG_UNUSED note if necessary for DEF in INSN updating
LIVE. Do not generate notes for registers in ARTIFICIAL_USES. */
-static rtx
-df_create_unused_note (rtx insn, rtx old, df_ref def,
- bitmap live, bitmap artificial_uses)
+static void
+df_create_unused_note (rtx insn, df_ref def,
+ bitmap live, bitmap artificial_uses,
+ struct dead_debug *debug)
{
unsigned int dregno = DF_REF_REGNO (def);
}
#endif
- if (!(bitmap_bit_p (live, dregno)
- || (DF_REF_FLAGS (def) & DF_REF_MW_HARDREG)
+ if (!((DF_REF_FLAGS (def) & DF_REF_MW_HARDREG)
+ || bitmap_bit_p (live, dregno)
|| bitmap_bit_p (artificial_uses, dregno)
|| df_ignore_stack_reg (dregno)))
{
rtx reg = (DF_REF_LOC (def))
? *DF_REF_REAL_LOC (def): DF_REF_REG (def);
- old = df_set_note (REG_UNUSED, insn, old, reg);
+ 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 old;
+ return;
}
+/* Initialize DEBUG to an empty list, and clear USED, if given. */
+static inline void
+dead_debug_init (struct dead_debug *debug, bitmap used)
+{
+ debug->head = NULL;
+ debug->used = used;
+ debug->to_rescan = NULL;
+ if (used)
+ bitmap_clear (used);
+}
+
+/* Reset all debug insns with pending uses. Release the bitmap in it,
+ unless it is USED. USED must be the same bitmap passed to
+ dead_debug_init. */
+static inline void
+dead_debug_finish (struct dead_debug *debug, bitmap used)
+{
+ struct dead_debug_use *head;
+ rtx insn = NULL;
+
+ if (debug->used != used)
+ BITMAP_FREE (debug->used);
+
+ while ((head = debug->head))
+ {
+ insn = DF_REF_INSN (head->use);
+ if (!head->next || DF_REF_INSN (head->next->use) != insn)
+ {
+ INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
+ df_insn_rescan_debug_internal (insn);
+ if (debug->to_rescan)
+ bitmap_clear_bit (debug->to_rescan, INSN_UID (insn));
+ }
+ debug->head = head->next;
+ XDELETE (head);
+ }
+
+ if (debug->to_rescan)
+ {
+ bitmap_iterator bi;
+ unsigned int uid;
+
+ EXECUTE_IF_SET_IN_BITMAP (debug->to_rescan, 0, uid, bi)
+ {
+ struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
+ if (insn_info)
+ df_insn_rescan (insn_info->insn);
+ }
+ BITMAP_FREE (debug->to_rescan);
+ }
+}
+
+/* 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
+dead_debug_add (struct dead_debug *debug, df_ref use, unsigned int uregno)
+{
+ struct dead_debug_use *newddu = XNEW (struct dead_debug_use);
+
+ newddu->use = use;
+ newddu->next = debug->head;
+ debug->head = newddu;
+
+ if (!debug->used)
+ debug->used = BITMAP_ALLOC (NULL);
+
+ bitmap_set_bit (debug->used, uregno);
+}
+
+/* If UREGNO is referenced by any entry in DEBUG, emit a debug insn
+ before INSN that binds the REG to a debug temp, and replace all
+ uses of UREGNO in DEBUG with uses of the debug temp. INSN must be
+ the insn where UREGNO dies. */
+static inline void
+dead_debug_insert_before (struct dead_debug *debug, unsigned int uregno,
+ rtx insn)
+{
+ struct dead_debug_use **tailp = &debug->head;
+ struct dead_debug_use *cur;
+ struct dead_debug_use *uses = NULL;
+ struct dead_debug_use **usesp = &uses;
+ rtx reg = NULL;
+ rtx dval;
+ rtx bind;
+
+ if (!debug->used || !bitmap_clear_bit (debug->used, uregno))
+ return;
+
+ /* Move all uses of uregno from debug->head to uses, setting mode to
+ the widest referenced mode. */
+ while ((cur = *tailp))
+ {
+ if (DF_REF_REGNO (cur->use) == uregno)
+ {
+ *usesp = cur;
+ usesp = &cur->next;
+ *tailp = cur->next;
+ cur->next = NULL;
+ if (!reg
+ || (GET_MODE_BITSIZE (GET_MODE (reg))
+ < GET_MODE_BITSIZE (GET_MODE (*DF_REF_REAL_LOC (cur->use)))))
+ reg = *DF_REF_REAL_LOC (cur->use);
+ }
+ else
+ tailp = &(*tailp)->next;
+ }
+
+ /* 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);
+
+ /* Emit a debug bind insn before the insn in which reg dies. */
+ bind = gen_rtx_VAR_LOCATION (GET_MODE (reg),
+ DEBUG_EXPR_TREE_DECL (dval), reg,
+ VAR_INIT_STATUS_INITIALIZED);
+
+ bind = emit_debug_insn_before (bind, insn);
+ df_insn_rescan (bind);
+
+ /* Adjust all uses. */
+ while ((cur = uses))
+ {
+ if (GET_MODE (*DF_REF_REAL_LOC (cur->use)) == GET_MODE (reg))
+ *DF_REF_REAL_LOC (cur->use) = dval;
+ else
+ *DF_REF_REAL_LOC (cur->use)
+ = gen_lowpart_SUBREG (GET_MODE (*DF_REF_REAL_LOC (cur->use)), dval);
+ /* ??? Should we simplify subreg of subreg? */
+ if (debug->to_rescan == NULL)
+ debug->to_rescan = BITMAP_ALLOC (NULL);
+ bitmap_set_bit (debug->to_rescan, INSN_UID (DF_REF_INSN (cur->use)));
+ uses = cur->next;
+ XDELETE (cur);
+ }
+}
+
/* Recompute the REG_DEAD and REG_UNUSED notes and compute register
info: lifetime, bb, and number of defs and uses for basic block
BB. The three bitvectors are scratch regs used here. */
rtx insn;
df_ref *def_rec;
df_ref *use_rec;
+ struct dead_debug debug;
+
+ dead_debug_init (&debug, NULL);
bitmap_copy (live, df_get_live_out (bb));
bitmap_clear (artificial_uses);
{
unsigned int uid = INSN_UID (insn);
struct df_mw_hardreg **mws_rec;
- rtx old_dead_notes;
- rtx old_unused_notes;
int debug_insn;
if (!INSN_P (insn))
debug_insn = DEBUG_INSN_P (insn);
bitmap_clear (do_not_gen);
- df_kill_notes (insn, &old_dead_notes, &old_unused_notes);
+ df_kill_notes (insn, live);
/* Process the defs. */
if (CALL_P (insn))
struct df_mw_hardreg *mws = *mws_rec;
if ((DF_MWS_REG_DEF_P (mws))
&& !df_ignore_stack_reg (mws->start_regno))
- old_unused_notes
- = df_set_unused_notes_for_mw (insn, old_unused_notes,
- mws, live, do_not_gen,
- artificial_uses);
+ df_set_unused_notes_for_mw (insn,
+ mws, live, do_not_gen,
+ artificial_uses, &debug);
mws_rec++;
}
unsigned int dregno = DF_REF_REGNO (def);
if (!DF_REF_FLAGS_IS_SET (def, DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))
{
- old_unused_notes
- = df_create_unused_note (insn, old_unused_notes,
- def, live, artificial_uses);
+ df_create_unused_note (insn,
+ def, live, artificial_uses, &debug);
bitmap_set_bit (do_not_gen, dregno);
}
{
struct df_mw_hardreg *mws = *mws_rec;
if (DF_MWS_REG_DEF_P (mws))
- old_unused_notes
- = df_set_unused_notes_for_mw (insn, old_unused_notes,
- mws, live, do_not_gen,
- artificial_uses);
+ df_set_unused_notes_for_mw (insn,
+ mws, live, do_not_gen,
+ artificial_uses, &debug);
mws_rec++;
}
{
df_ref def = *def_rec;
unsigned int dregno = DF_REF_REGNO (def);
- old_unused_notes
- = df_create_unused_note (insn, old_unused_notes,
- def, live, artificial_uses);
+ df_create_unused_note (insn,
+ 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;
- old_dead_notes
- = df_set_dead_notes_for_mw (insn, old_dead_notes,
- mws, live, do_not_gen,
- artificial_uses,
- &really_add_notes);
+ df_set_dead_notes_for_mw (insn,
+ mws, live, do_not_gen,
+ artificial_uses,
+ &really_add_notes);
if (really_add_notes)
debug_insn = -1;
{
if (debug_insn)
{
- debug_insn = -1;
+ if (debug_insn > 0)
+ {
+ dead_debug_add (&debug, use, uregno);
+ continue;
+ }
break;
}
+ else
+ dead_debug_insert_before (&debug, uregno, insn);
- if ( (!(DF_REF_FLAGS (use) & DF_REF_MW_HARDREG))
+ if ( (!(DF_REF_FLAGS (use)
+ & (DF_REF_MW_HARDREG | DF_REF_READ_WRITE)))
&& (!bitmap_bit_p (do_not_gen, uregno))
&& (!bitmap_bit_p (artificial_uses, uregno))
- && (!(DF_REF_FLAGS (use) & DF_REF_READ_WRITE))
&& (!df_ignore_stack_reg (uregno)))
{
rtx reg = (DF_REF_LOC (use))
? *DF_REF_REAL_LOC (use) : DF_REF_REG (use);
- old_dead_notes = df_set_note (REG_DEAD, insn, old_dead_notes, reg);
+ df_set_note (REG_DEAD, insn, reg);
#ifdef REG_DEAD_DEBUGGING
df_print_note ("adding 4: ", insn, REG_NOTES (insn));
}
}
- while (old_unused_notes)
- {
- rtx next = XEXP (old_unused_notes, 1);
- free_EXPR_LIST_node (old_unused_notes);
- old_unused_notes = next;
- }
- while (old_dead_notes)
- {
- rtx next = XEXP (old_dead_notes, 1);
- free_EXPR_LIST_node (old_dead_notes);
- old_dead_notes = next;
- }
-
if (debug_insn == -1)
{
/* ??? We could probably do better here, replacing dead
df_insn_rescan_debug_internal (insn);
}
}
+
+ dead_debug_finish (&debug, NULL);
}
{
unsigned int bb_index;
bitmap_iterator bi;
- bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
- bitmap do_not_gen = BITMAP_ALLOC (&df_bitmap_obstack);
- bitmap artificial_uses = BITMAP_ALLOC (&df_bitmap_obstack);
+ bitmap_head live, do_not_gen, artificial_uses;
+
+ bitmap_initialize (&live, &df_bitmap_obstack);
+ bitmap_initialize (&do_not_gen, &df_bitmap_obstack);
+ bitmap_initialize (&artificial_uses, &df_bitmap_obstack);
#ifdef REG_DEAD_DEBUGGING
if (dump_file)
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- df_note_bb_compute (bb_index, live, do_not_gen, artificial_uses);
+ df_note_bb_compute (bb_index, &live, &do_not_gen, &artificial_uses);
}
- BITMAP_FREE (live);
- BITMAP_FREE (do_not_gen);
- BITMAP_FREE (artificial_uses);
+ bitmap_clear (&live);
+ bitmap_clear (&do_not_gen);
+ bitmap_clear (&artificial_uses);
}
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
&problem_LR, /* Dependent problem. */
+ sizeof (struct df_scan_bb_info),/* Size of entry of block_info array. */
TV_DF_NOTE, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
}
}
+/* 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
/* These regs are considered always live so if they end up dying
because of some def, we need to bring the back again. */
if (bb_has_eh_pred (bb))
- bitmap_ior_into (live, df->eh_block_artificial_uses);
+ bitmap_ior_into (live, &df->eh_block_artificial_uses);
else
- bitmap_ior_into (live, df->regular_block_artificial_uses);
+ bitmap_ior_into (live, &df->regular_block_artificial_uses);
}
{
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
/*----------------------------------------------------------------------------
propagating the information to BB3's successors.
---------------------------------------------------------------------------*/
+/* Private data used to verify the solution for this problem. */
+struct df_md_problem_data
+{
+ /* An obstack for the bitmaps we need for this problem. */
+ bitmap_obstack md_bitmaps;
+};
+
/* Scratch var used by transfer functions. This is used to do md analysis
only for live registers. */
-static bitmap df_md_scratch;
-
-/* Set basic block info. */
-
-static void
-df_md_set_bb_info (unsigned int index,
- struct df_md_bb_info *bb_info)
-{
- gcc_assert (df_md);
- gcc_assert (index < df_md->block_info_size);
- df_md->block_info[index] = bb_info;
-}
+static bitmap_head df_md_scratch;
static void
struct df_md_bb_info *bb_info = (struct df_md_bb_info *) vbb_info;
if (bb_info)
{
- BITMAP_FREE (bb_info->kill);
- BITMAP_FREE (bb_info->gen);
- BITMAP_FREE (bb_info->init);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- pool_free (df_md->block_pool, bb_info);
+ bitmap_clear (&bb_info->kill);
+ bitmap_clear (&bb_info->gen);
+ bitmap_clear (&bb_info->init);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
{
unsigned int bb_index;
bitmap_iterator bi;
-
- if (!df_md->block_pool)
- df_md->block_pool = create_alloc_pool ("df_md_block pool",
- sizeof (struct df_md_bb_info), 50);
+ struct df_md_problem_data *problem_data;
df_grow_bb_info (df_md);
- df_md_scratch = BITMAP_ALLOC (NULL);
+ if (df_md->problem_data)
+ problem_data = (struct df_md_problem_data *) df_md->problem_data;
+ else
+ {
+ problem_data = XNEW (struct df_md_problem_data);
+ df_md->problem_data = problem_data;
+ bitmap_obstack_initialize (&problem_data->md_bitmaps);
+ }
+ bitmap_initialize (&df_md_scratch, &problem_data->md_bitmaps);
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
- if (bb_info)
+ /* When bitmaps are already initialized, just clear them. */
+ if (bb_info->init.obstack)
{
- bitmap_clear (bb_info->init);
- bitmap_clear (bb_info->gen);
- bitmap_clear (bb_info->kill);
- bitmap_clear (bb_info->in);
- bitmap_clear (bb_info->out);
+ bitmap_clear (&bb_info->init);
+ bitmap_clear (&bb_info->gen);
+ bitmap_clear (&bb_info->kill);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
else
{
- bb_info = (struct df_md_bb_info *) pool_alloc (df_md->block_pool);
- df_md_set_bb_info (bb_index, bb_info);
- bb_info->init = BITMAP_ALLOC (NULL);
- bb_info->gen = BITMAP_ALLOC (NULL);
- bb_info->kill = BITMAP_ALLOC (NULL);
- bb_info->in = BITMAP_ALLOC (NULL);
- bb_info->out = BITMAP_ALLOC (NULL);
+ bitmap_initialize (&bb_info->init, &problem_data->md_bitmaps);
+ bitmap_initialize (&bb_info->gen, &problem_data->md_bitmaps);
+ bitmap_initialize (&bb_info->kill, &problem_data->md_bitmaps);
+ bitmap_initialize (&bb_info->in, &problem_data->md_bitmaps);
+ bitmap_initialize (&bb_info->out, &problem_data->md_bitmaps);
}
}
int top_flag)
{
df_ref def;
- bitmap_clear (seen_in_insn);
+ bitmap_clear (&seen_in_insn);
while ((def = *def_rec++) != NULL)
{
|| (dregno >= FIRST_PSEUDO_REGISTER))
&& top_flag == (DF_REF_FLAGS (def) & DF_REF_AT_TOP))
{
- if (!bitmap_bit_p (seen_in_insn, dregno))
+ if (!bitmap_bit_p (&seen_in_insn, dregno))
{
if (DF_REF_FLAGS (def)
& (DF_REF_PARTIAL | DF_REF_CONDITIONAL | DF_REF_MAY_CLOBBER))
{
- bitmap_set_bit (bb_info->gen, dregno);
- bitmap_clear_bit (bb_info->kill, dregno);
+ bitmap_set_bit (&bb_info->gen, dregno);
+ bitmap_clear_bit (&bb_info->kill, dregno);
}
else
{
/* When we find a clobber and a regular def,
make sure the regular def wins. */
- bitmap_set_bit (seen_in_insn, dregno);
- bitmap_set_bit (bb_info->kill, dregno);
- bitmap_clear_bit (bb_info->gen, dregno);
+ bitmap_set_bit (&seen_in_insn, dregno);
+ bitmap_set_bit (&bb_info->kill, dregno);
+ bitmap_clear_bit (&bb_info->gen, dregno);
}
}
}
unsigned int bb_index, df_bb_index;
bitmap_iterator bi1, bi2;
basic_block bb;
- bitmap *frontiers;
+ bitmap_head *frontiers;
- seen_in_insn = BITMAP_ALLOC (NULL);
+ bitmap_initialize (&seen_in_insn, &bitmap_default_obstack);
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi1)
{
df_md_bb_local_compute (bb_index);
}
- BITMAP_FREE (seen_in_insn);
+ bitmap_clear (&seen_in_insn);
- frontiers = XNEWVEC (bitmap, last_basic_block);
+ frontiers = XNEWVEC (bitmap_head, last_basic_block);
FOR_ALL_BB (bb)
- frontiers[bb->index] = BITMAP_ALLOC (NULL);
+ bitmap_initialize (&frontiers[bb->index], &bitmap_default_obstack);
compute_dominance_frontiers (frontiers);
/* Add each basic block's kills to the nodes in the frontier of the BB. */
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi1)
{
- bitmap kill = df_md_get_bb_info (bb_index)->kill;
- EXECUTE_IF_SET_IN_BITMAP (frontiers[bb_index], 0, df_bb_index, bi2)
+ bitmap kill = &df_md_get_bb_info (bb_index)->kill;
+ EXECUTE_IF_SET_IN_BITMAP (&frontiers[bb_index], 0, df_bb_index, bi2)
{
basic_block bb = BASIC_BLOCK (df_bb_index);
if (bitmap_bit_p (all_blocks, df_bb_index))
- bitmap_ior_and_into (df_md_get_bb_info (df_bb_index)->init, kill,
+ bitmap_ior_and_into (&df_md_get_bb_info (df_bb_index)->init, kill,
df_get_live_in (bb));
}
}
FOR_ALL_BB (bb)
- BITMAP_FREE (frontiers[bb->index]);
+ bitmap_clear (&frontiers[bb->index]);
free (frontiers);
}
{
struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
gcc_assert (bb_info);
- bitmap_clear (bb_info->in);
- bitmap_clear (bb_info->out);
+ bitmap_clear (&bb_info->in);
+ bitmap_clear (&bb_info->out);
}
}
{
basic_block bb = BASIC_BLOCK (bb_index);
struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
- bitmap in = bb_info->in;
- bitmap out = bb_info->out;
- bitmap gen = bb_info->gen;
- bitmap kill = bb_info->kill;
+ bitmap in = &bb_info->in;
+ bitmap out = &bb_info->out;
+ bitmap gen = &bb_info->gen;
+ bitmap kill = &bb_info->kill;
/* We need to use a scratch set here so that the value returned from this
function invocation properly reflects whether the sets changed in a
significant way; i.e. not just because the live set was anded in. */
- bitmap_and (df_md_scratch, gen, df_get_live_out (bb));
+ bitmap_and (&df_md_scratch, gen, df_get_live_out (bb));
/* Multiple definitions of a register are not relevant if it is not
live. Thus we trim the result to the places where it is live. */
bitmap_and_into (in, df_get_live_in (bb));
- return bitmap_ior_and_compl (out, df_md_scratch, in, kill);
+ return bitmap_ior_and_compl (out, &df_md_scratch, in, kill);
}
/* Initialize the solution bit vectors for problem. */
{
struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
- bitmap_copy (bb_info->in, bb_info->init);
+ bitmap_copy (&bb_info->in, &bb_info->init);
df_md_transfer_function (bb_index);
}
}
df_md_confluence_0 (basic_block bb)
{
struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
- bitmap_copy (bb_info->in, bb_info->init);
+ bitmap_copy (&bb_info->in, &bb_info->init);
}
/* In of target gets or of out of source. */
-static void
+static bool
df_md_confluence_n (edge e)
{
- bitmap op1 = df_md_get_bb_info (e->dest->index)->in;
- bitmap op2 = df_md_get_bb_info (e->src->index)->out;
+ bitmap op1 = &df_md_get_bb_info (e->dest->index)->in;
+ bitmap op2 = &df_md_get_bb_info (e->src->index)->out;
if (e->flags & EDGE_FAKE)
- return;
+ return false;
if (e->flags & EDGE_EH)
- bitmap_ior_and_compl_into (op1, op2, regs_invalidated_by_call_regset);
+ return bitmap_ior_and_compl_into (op1, op2,
+ regs_invalidated_by_call_regset);
else
- bitmap_ior_into (op1, op2);
+ return bitmap_ior_into (op1, op2);
}
/* Free all storage associated with the problem. */
static void
df_md_free (void)
{
- unsigned int i;
- for (i = 0; i < df_md->block_info_size; i++)
- {
- struct df_md_bb_info *bb_info = df_md_get_bb_info (i);
- if (bb_info)
- {
- BITMAP_FREE (bb_info->kill);
- BITMAP_FREE (bb_info->gen);
- BITMAP_FREE (bb_info->init);
- BITMAP_FREE (bb_info->in);
- BITMAP_FREE (bb_info->out);
- }
- }
+ struct df_md_problem_data *problem_data
+ = (struct df_md_problem_data *) df_md->problem_data;
- BITMAP_FREE (df_md_scratch);
- free_alloc_pool (df_md->block_pool);
+ bitmap_obstack_release (&problem_data->md_bitmaps);
+ free (problem_data);
+ df_md->problem_data = NULL;
df_md->block_info_size = 0;
free (df_md->block_info);
+ df_md->block_info = NULL;
free (df_md);
}
df_md_top_dump (basic_block bb, FILE *file)
{
struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
- if (!bb_info || !bb_info->in)
+ if (!bb_info)
return;
fprintf (file, ";; md in \t");
- df_print_regset (file, bb_info->in);
+ df_print_regset (file, &bb_info->in);
fprintf (file, ";; md init \t");
- df_print_regset (file, bb_info->init);
+ df_print_regset (file, &bb_info->init);
fprintf (file, ";; md gen \t");
- df_print_regset (file, bb_info->gen);
+ df_print_regset (file, &bb_info->gen);
fprintf (file, ";; md kill \t");
- df_print_regset (file, bb_info->kill);
+ df_print_regset (file, &bb_info->kill);
}
/* Debugging info at bottom of bb. */
df_md_bottom_dump (basic_block bb, FILE *file)
{
struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
- if (!bb_info || !bb_info->out)
+ if (!bb_info)
return;
fprintf (file, ";; md out \t");
- df_print_regset (file, bb_info->out);
+ df_print_regset (file, &bb_info->out);
}
static struct df_problem problem_MD =
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
+ sizeof (struct df_md_bb_info),/* Size of entry of block_info array. */
TV_DF_MD, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
OSDN Git Service
