/* Standard problems for dataflow support routines.
- Copyright (C) 1999-2016 Free Software Foundation, Inc.
+ Copyright (C) 1999-2020 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 "target.h"
#include "rtl.h"
#include "df.h"
+#include "memmodel.h"
#include "tm_p.h"
#include "insn-config.h"
#include "cfganal.h"
#include "valtrack.h"
#include "dumpfile.h"
#include "rtl-iter.h"
+#include "regs.h"
+#include "function-abi.h"
/* Note that turning REG_DEAD_DEBUGGING on will cause
gcc.c-torture/unsorted/dump-noaddr.c to fail because it prints
these along with the bitmap_clear_range call to remove ranges of
bits without actually generating a knockout vector.
- The kill and sparse_kill and the dense_invalidated_by_call and
- sparse_invalidated_by_call both play this game. */
+ The kill and sparse_kill and the dense_invalidated_by_eh and
+ sparse_invalidated_by_eh both play this game. */
/* Private data used to compute the solution for this problem. These
data structures are not accessible outside of this module. */
-struct df_rd_problem_data
+class df_rd_problem_data
{
- /* The set of defs to regs invalidated by call. */
- bitmap_head sparse_invalidated_by_call;
- /* The set of defs to regs invalidate by call for rd. */
- bitmap_head dense_invalidated_by_call;
+public:
+ /* The set of defs to regs invalidated by EH edges. */
+ bitmap_head sparse_invalidated_by_eh;
+ bitmap_head dense_invalidated_by_eh;
/* An obstack for the bitmaps we need for this problem. */
bitmap_obstack rd_bitmaps;
};
df_rd_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_rd_bb_info *bb_info = (struct df_rd_bb_info *) vbb_info;
+ class df_rd_bb_info *bb_info = (class df_rd_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->kill);
{
unsigned int bb_index;
bitmap_iterator bi;
- struct df_rd_problem_data *problem_data;
+ class df_rd_problem_data *problem_data;
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);
+ problem_data = (class df_rd_problem_data *) df_rd->problem_data;
+ bitmap_clear (&problem_data->sparse_invalidated_by_eh);
+ bitmap_clear (&problem_data->dense_invalidated_by_eh);
}
else
{
- problem_data = XNEW (struct df_rd_problem_data);
+ problem_data = XNEW (class df_rd_problem_data);
df_rd->problem_data = problem_data;
bitmap_obstack_initialize (&problem_data->rd_bitmaps);
- bitmap_initialize (&problem_data->sparse_invalidated_by_call,
+ bitmap_initialize (&problem_data->sparse_invalidated_by_eh,
&problem_data->rd_bitmaps);
- bitmap_initialize (&problem_data->dense_invalidated_by_call,
+ bitmap_initialize (&problem_data->dense_invalidated_by_eh,
&problem_data->rd_bitmaps);
}
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);
+ class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
/* When bitmaps are already initialized, just clear them. */
if (bb_info->kill.obstack)
of kill sets. */
static void
-df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info,
+df_rd_bb_local_compute_process_def (class df_rd_bb_info *bb_info,
df_ref def,
int top_flag)
{
df_rd_bb_local_compute (unsigned int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+ class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
rtx_insn *insn;
bitmap_clear (&seen_in_block);
{
unsigned int bb_index;
bitmap_iterator bi;
- 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;
+ class df_rd_problem_data *problem_data
+ = (class df_rd_problem_data *) df_rd->problem_data;
+ bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_eh;
+ bitmap dense_invalidated = &problem_data->dense_invalidated_by_eh;
bitmap_initialize (&seen_in_block, &df_bitmap_obstack);
bitmap_initialize (&seen_in_insn, &df_bitmap_obstack);
df_rd_bb_local_compute (bb_index);
}
- /* Set up the knockout bit vectors to be applied across EH_EDGES. */
- EXECUTE_IF_SET_IN_BITMAP (regs_invalidated_by_call_regset, 0, regno, bi)
- {
- if (! HARD_REGISTER_NUM_P (regno)
- || !(df->changeable_flags & DF_NO_HARD_REGS))
+ /* Set up the knockout bit vectors to be applied across EH_EDGES.
+ Conservatively treat partially-clobbered registers as surviving
+ across the EH edge, i.e. assume that definitions before the edge
+ is taken *might* reach uses after it has been taken. */
+ if (!(df->changeable_flags & DF_NO_HARD_REGS))
+ for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
+ if (eh_edge_abi.clobbers_full_reg_p (regno))
{
if (DF_DEFS_COUNT (regno) > DF_SPARSE_THRESHOLD)
bitmap_set_bit (sparse_invalidated, regno);
DF_DEFS_BEGIN (regno),
DF_DEFS_COUNT (regno));
}
- }
- bitmap_clear (&seen_in_block);
- bitmap_clear (&seen_in_insn);
+ bitmap_release (&seen_in_block);
+ bitmap_release (&seen_in_insn);
}
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);
+ class 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);
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;
+ class df_rd_problem_data *problem_data
+ = (class df_rd_problem_data *) df_rd->problem_data;
+ bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_eh;
+ bitmap dense_invalidated = &problem_data->dense_invalidated_by_eh;
bitmap_iterator bi;
unsigned int regno;
- bitmap_head tmp;
- bitmap_initialize (&tmp, &df_bitmap_obstack);
- bitmap_and_compl (&tmp, op2, dense_invalidated);
+ auto_bitmap tmp (&df_bitmap_obstack);
+ bitmap_and_compl (tmp, op2, 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));
}
- changed |= bitmap_ior_into (op1, &tmp);
- bitmap_clear (&tmp);
+ changed |= bitmap_ior_into (op1, tmp);
return changed;
}
else
static bool
df_rd_transfer_function (int bb_index)
{
- struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+ class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
unsigned int regno;
bitmap_iterator bi;
bitmap in = &bb_info->in;
changed = bitmap_ior_and_compl (out, gen, in, kill);
else
{
- struct df_rd_problem_data *problem_data;
+ class df_rd_problem_data *problem_data;
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;
+ problem_data = (class df_rd_problem_data *) df_rd->problem_data;
bitmap_initialize (&tmp, &problem_data->rd_bitmaps);
bitmap_and_compl (&tmp, in, kill);
bitmap_ior_into (&tmp, gen);
changed = !bitmap_equal_p (&tmp, out);
if (changed)
- {
- bitmap_clear (out);
- bb_info->out = tmp;
- }
+ bitmap_move (out, &tmp);
else
bitmap_clear (&tmp);
}
basic block, and mask out DEFs of registers that are not live.
Computing the mask looks costly, but the benefit of the pruning
outweighs the cost. */
- struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+ class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
bitmap regs_live_out = &df_lr_get_bb_info (bb_index)->out;
bitmap live_defs = BITMAP_ALLOC (&df_bitmap_obstack);
unsigned int regno;
static void
df_rd_free (void)
{
- struct df_rd_problem_data *problem_data
- = (struct df_rd_problem_data *) df_rd->problem_data;
+ class df_rd_problem_data *problem_data
+ = (class df_rd_problem_data *) df_rd->problem_data;
if (problem_data)
{
static void
df_rd_start_dump (FILE *file)
{
- struct df_rd_problem_data *problem_data
- = (struct df_rd_problem_data *) df_rd->problem_data;
+ class df_rd_problem_data *problem_data
+ = (class df_rd_problem_data *) df_rd->problem_data;
unsigned int m = DF_REG_SIZE (df);
unsigned int regno;
fprintf (file, ";; Reaching defs:\n");
fprintf (file, ";; sparse invalidated \t");
- dump_bitmap (file, &problem_data->sparse_invalidated_by_call);
+ dump_bitmap (file, &problem_data->sparse_invalidated_by_eh);
fprintf (file, ";; dense invalidated \t");
- dump_bitmap (file, &problem_data->dense_invalidated_by_call);
+ dump_bitmap (file, &problem_data->dense_invalidated_by_eh);
fprintf (file, ";; reg->defs[] map:\t");
for (regno = 0; regno < m; regno++)
static void
df_rd_top_dump (basic_block bb, FILE *file)
{
- struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
+ class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
if (!bb_info)
return;
static void
df_rd_bottom_dump (basic_block bb, FILE *file)
{
- struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
+ class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
if (!bb_info)
return;
/* All of the information associated with every instance of the problem. */
-static struct df_problem problem_RD =
+static const struct df_problem problem_RD =
{
DF_RD, /* Problem id. */
DF_FORWARD, /* Direction. */
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. */
+ sizeof (class 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. */
};
df_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_lr_bb_info *bb_info = (struct df_lr_bb_info *) vbb_info;
+ class df_lr_bb_info *bb_info = (class df_lr_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->use);
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);
+ class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
/* When bitmaps are already initialized, just clear them. */
if (bb_info->use.obstack)
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);
+ class 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);
df_lr_bb_local_compute (unsigned int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
+ class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
rtx_insn *insn;
df_ref def, use;
{
/* 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);
+ class df_lr_bb_info *bb_info = df_lr_get_bb_info (EXIT_BLOCK);
bitmap_copy (&bb_info->use, df->exit_block_uses);
}
else
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);
+ class 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 op2 = &df_lr_get_bb_info (e->dest->index)->in;
bool changed = false;
- /* Call-clobbered registers die across exception and call edges. */
+ /* Call-clobbered registers die across exception and call edges.
+ Conservatively treat partially-clobbered registers as surviving
+ across the edges; they might or might not, depending on what
+ mode they have. */
/* ??? Abnormal call edges ignored for the moment, as this gets
confused by sibling call edges, which crashes reg-stack. */
if (e->flags & EDGE_EH)
- changed = bitmap_ior_and_compl_into (op1, op2, regs_invalidated_by_call_regset);
+ {
+ bitmap_view<HARD_REG_SET> eh_kills (eh_edge_abi.full_reg_clobbers ());
+ changed = bitmap_ior_and_compl_into (op1, op2, eh_kills);
+ }
else
changed = bitmap_ior_into (op1, op2);
static bool
df_lr_transfer_function (int bb_index)
{
- struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
+ class 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;
static void
df_lr_top_dump (basic_block bb, FILE *file)
{
- struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
+ class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
struct df_lr_problem_data *problem_data;
if (!bb_info)
return;
static void
df_lr_bottom_dump (basic_block bb, FILE *file)
{
- struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
+ class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
struct df_lr_problem_data *problem_data;
if (!bb_info)
return;
/* All of the information associated with every instance of the problem. */
-static struct df_problem problem_LR =
+static const struct df_problem problem_LR =
{
DF_LR, /* Problem id. */
DF_BACKWARD, /* Direction. */
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. */
+ sizeof (class 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. */
};
FOR_ALL_BB_FN (bb, cfun)
{
- struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
+ class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
bitmap_set_bit (&all_blocks, bb->index);
if (bb_info)
df_live_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_live_bb_info *bb_info = (struct df_live_bb_info *) vbb_info;
+ class df_live_bb_info *bb_info = (class df_live_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->gen);
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);
+ class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
/* When bitmaps are already initialized, just clear them. */
if (bb_info->kill.obstack)
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+ class 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);
df_live_bb_local_compute (unsigned int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+ class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
rtx_insn *insn;
df_ref def;
int luid = 0;
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- 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);
+ class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+ class df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
/* No register may reach a location where it is not used. Thus
we trim the rr result to the places where it is used. */
static bool
df_live_transfer_function (int bb_index)
{
- 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);
+ class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+ class 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;
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
- struct df_live_bb_info *bb_live_info = df_live_get_bb_info (bb_index);
+ class df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
+ class df_live_bb_info *bb_live_info = df_live_get_bb_info (bb_index);
/* No register may reach a location where it is not used. Thus
we trim the rr result to the places where it is used. */
df_live->block_info_size = 0;
free (df_live->block_info);
df_live->block_info = NULL;
- bitmap_clear (&df_live_scratch);
+ bitmap_release (&df_live_scratch);
bitmap_obstack_release (&problem_data->live_bitmaps);
free (problem_data);
df_live->problem_data = NULL;
static void
df_live_top_dump (basic_block bb, FILE *file)
{
- struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
+ class df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
struct df_live_problem_data *problem_data;
if (!bb_info)
static void
df_live_bottom_dump (basic_block bb, FILE *file)
{
- struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
+ class df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
struct df_live_problem_data *problem_data;
if (!bb_info)
/* All of the information associated with every instance of the problem. */
-static struct df_problem problem_LIVE =
+static const struct df_problem problem_LIVE =
{
DF_LIVE, /* Problem id. */
DF_FORWARD, /* Direction. */
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. */
+ sizeof (class 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. */
};
FOR_ALL_BB_FN (bb, cfun)
{
- struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
+ class df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
bitmap_set_bit (&all_blocks, bb->index);
if (bb_info)
df_mir_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_mir_bb_info *bb_info = (struct df_mir_bb_info *) vbb_info;
+ class df_mir_bb_info *bb_info = (class df_mir_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->gen);
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+ class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
/* When bitmaps are already initialized, just clear them. */
if (bb_info->kill.obstack)
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+ class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
gcc_assert (bb_info);
df_mir_bb_local_compute (unsigned int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+ class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
rtx_insn *insn;
int luid = 0;
static void
df_mir_confluence_0 (basic_block bb)
{
- struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
+ class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
bitmap_clear (&bb_info->in);
}
static bool
df_mir_transfer_function (int bb_index)
{
- struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+ class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
bitmap in = &bb_info->in;
bitmap out = &bb_info->out;
bitmap gen = &bb_info->gen;
static void
df_mir_top_dump (basic_block bb, FILE *file)
{
- struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
+ class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
if (!bb_info)
return;
static void
df_mir_bottom_dump (basic_block bb, FILE *file)
{
- struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
+ class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
if (!bb_info)
return;
/* All of the information associated with every instance of the problem. */
-static struct df_problem problem_MIR =
+static const struct df_problem problem_MIR =
{
DF_MIR, /* Problem id. */
DF_FORWARD, /* Direction. */
df_mir_verify_solution_start, /* Incremental solution verify start. */
df_mir_verify_solution_end, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
- sizeof (struct df_mir_bb_info),/* Size of entry of block_info array. */
+ sizeof (class df_mir_bb_info),/* Size of entry of block_info array. */
TV_DF_MIR, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
df_chain_create_bb (unsigned int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+ class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
rtx_insn *insn;
bitmap_head cpy;
}
}
-static struct df_problem problem_CHAIN =
+static const struct df_problem problem_CHAIN =
{
DF_CHAIN, /* Problem id. */
DF_NONE, /* Direction. */
df_word_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_word_lr_bb_info *bb_info = (struct df_word_lr_bb_info *) vbb_info;
+ class df_word_lr_bb_info *bb_info = (class df_word_lr_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->use);
EXECUTE_IF_SET_IN_BITMAP (df_word_lr->out_of_date_transfer_functions, 0, bb_index, bi)
{
- struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+ class 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)
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+ class 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);
regno = REGNO (reg);
reg_mode = GET_MODE (reg);
if (regno < FIRST_PSEUDO_REGISTER
- || GET_MODE_SIZE (reg_mode) != 2 * UNITS_PER_WORD)
+ || maybe_ne (GET_MODE_SIZE (reg_mode), 2 * UNITS_PER_WORD))
return true;
if (GET_CODE (orig_reg) == SUBREG
- && df_read_modify_subreg_p (orig_reg))
+ && read_modify_subreg_p (orig_reg))
{
gcc_assert (DF_REF_FLAGS_IS_SET (ref, DF_REF_PARTIAL));
if (subreg_lowpart_p (orig_reg))
df_word_lr_bb_local_compute (unsigned int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+ class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
rtx_insn *insn;
df_ref def, use;
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+ class 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);
}
static bool
df_word_lr_transfer_function (int bb_index)
{
- struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+ class 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;
static void
df_word_lr_top_dump (basic_block bb, FILE *file)
{
- struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
+ class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
if (!bb_info)
return;
static void
df_word_lr_bottom_dump (basic_block bb, FILE *file)
{
- struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
+ class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
if (!bb_info)
return;
/* All of the information associated with every instance of the problem. */
-static struct df_problem problem_WORD_LR =
+static const struct df_problem problem_WORD_LR =
{
DF_WORD_LR, /* Problem id. */
DF_BACKWARD, /* Direction. */
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
- sizeof (struct df_word_lr_bb_info),/* Size of entry of block_info array. */
+ sizeof (class 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. */
};
bool deleted = false;
FOR_EACH_INSN_EQ_USE (use, insn)
- if (DF_REF_REGNO (use) > FIRST_PSEUDO_REGISTER
+ 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))
FOR_BB_INSNS_REVERSE (bb, insn)
{
+ if (!INSN_P (insn))
+ continue;
+
df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
df_mw_hardreg *mw;
int debug_insn;
- if (!INSN_P (insn))
- continue;
-
debug_insn = DEBUG_INSN_P (insn);
bitmap_clear (do_not_gen);
/* All of the information associated every instance of the problem. */
-static struct df_problem problem_NOTE =
+static const struct df_problem problem_NOTE =
{
DF_NOTE, /* Problem id. */
DF_NONE, /* Direction. */
if (volatile_insn_p (PATTERN (insn)))
return false;
memrefs_in_across |= find_memory (insn);
- note_stores (PATTERN (insn), find_memory_stores,
- &mem_sets_in_across);
+ note_stores (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));
{
int mem_ref_flags = 0;
int mem_set_flags = 0;
- note_stores (PATTERN (insn), find_memory_stores, &mem_set_flags);
+ note_stores (insn, find_memory_stores, &mem_set_flags);
mem_ref_flags = find_memory (insn);
/* Catch sets of the stack pointer. */
mem_ref_flags |= mem_set_flags;
df_md_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_md_bb_info *bb_info = (struct df_md_bb_info *) vbb_info;
+ class df_md_bb_info *bb_info = (class df_md_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->kill);
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);
+ class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
/* When bitmaps are already initialized, just clear them. */
if (bb_info->init.obstack)
{
}
static void
-df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info,
+df_md_bb_local_compute_process_def (class df_md_bb_info *bb_info,
df_ref def,
int top_flag)
{
df_md_bb_local_compute (unsigned int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
+ class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
rtx_insn *insn;
/* Artificials are only hard regs. */
df_md_bb_local_compute (bb_index);
}
- bitmap_clear (&seen_in_insn);
+ bitmap_release (&seen_in_insn);
frontiers = XNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
FOR_ALL_BB_FN (bb, cfun)
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);
+ class 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);
df_md_transfer_function (int bb_index)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
- struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
+ class 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;
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);
+ class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
bitmap_copy (&bb_info->in, &bb_info->init);
df_md_transfer_function (bb_index);
static void
df_md_confluence_0 (basic_block bb)
{
- struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
+ class df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
bitmap_copy (&bb_info->in, &bb_info->init);
}
return false;
if (e->flags & EDGE_EH)
- return bitmap_ior_and_compl_into (op1, op2,
- regs_invalidated_by_call_regset);
+ {
+ /* Conservatively treat partially-clobbered registers as surviving
+ across the edge; they might or might not, depending on what mode
+ they have. */
+ bitmap_view<HARD_REG_SET> eh_kills (eh_edge_abi.full_reg_clobbers ());
+ return bitmap_ior_and_compl_into (op1, op2, eh_kills);
+ }
else
return bitmap_ior_into (op1, op2);
}
struct df_md_problem_data *problem_data
= (struct df_md_problem_data *) df_md->problem_data;
+ bitmap_release (&df_md_scratch);
bitmap_obstack_release (&problem_data->md_bitmaps);
free (problem_data);
df_md->problem_data = NULL;
static void
df_md_top_dump (basic_block bb, FILE *file)
{
- struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
+ class df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
if (!bb_info)
return;
static void
df_md_bottom_dump (basic_block bb, FILE *file)
{
- struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
+ class df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
if (!bb_info)
return;
df_print_regset (file, &bb_info->out);
}
-static struct df_problem problem_MD =
+static const struct df_problem problem_MD =
{
DF_MD, /* Problem id. */
DF_FORWARD, /* Direction. */
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. */
+ sizeof (class 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. */
};