+2005-01-21 Kenneth Zadeck <zadeck@naturalbridge.com>
+
+ * df-scan.c (problem_SCAN): Added NULL reset function.
+ (df_scan_reset_blocks): Added code to call reset block function
+ (df_bb_refs_delete) Fixed comment.
+ (df_insn_refs_delete): Made tolerant of deleting non existent info
+ for dataflow problems that need to be reset.
+ * df-core.c (df_set_blocks): Ditto.
+ * df.h (struct df_problem): Added reset_fun.
+ * df-problems.c (problem_RU, problem_RD, problem_LR, problem_UR,
+ problem_UREC, problem_CHAIN, problem_RI): Initialized reset_fun field.
+ (df_chain_insn_reset, df_chain_bb_reset, df_chain_reset): New
+ functions to clear out all references to def-use or use-def chains.
+
2006-01-21 Ben Elliston <bje@au.ibm.com>
* varasm.c (assemble_real): Initialise data array.
static struct df *ddf = NULL;
struct df *shared_df = NULL;
+static void * df_get_bb_info (struct dataflow *, unsigned int);
+static void df_set_bb_info (struct dataflow *, unsigned int, void *);
/*----------------------------------------------------------------------------
Functions to create, destroy and manipulate an instance of df.
----------------------------------------------------------------------------*/
{
int p;
bitmap diff = BITMAP_ALLOC (NULL);
+ bitmap all = BITMAP_ALLOC (NULL);
bitmap_and_compl (diff, df->blocks_to_analyze, blocks);
- for (p = 0; p < df->num_problems_defined; p++)
+ for (p = df->num_problems_defined - 1; p >= 0 ;p--)
{
struct dataflow *dflow = df->problems_in_order[p];
- if (*dflow->problem->free_bb_fun)
+ if (*dflow->problem->reset_fun)
+ (*dflow->problem->reset_fun) (dflow, df->blocks_to_analyze);
+ else if (*dflow->problem->free_bb_fun)
{
bitmap_iterator bi;
unsigned int bb_index;
EXECUTE_IF_SET_IN_BITMAP (diff, 0, bb_index, bi)
{
basic_block bb = BASIC_BLOCK (bb_index);
- (*dflow->problem->free_bb_fun) (dflow, bb, diff);
+ if (bb)
+ {
+ (*dflow->problem->free_bb_fun)
+ (dflow, bb, df_get_bb_info (dflow, bb_index));
+ df_set_bb_info (dflow, bb_index, NULL);
+ }
}
}
}
+ BITMAP_FREE (all);
BITMAP_FREE (diff);
}
else
- df->blocks_to_analyze = BITMAP_ALLOC (NULL);
+ {
+ /* If we have not actually run scanning before, do not try
+ to clear anything. */
+ struct dataflow *scan_dflow = df->problems_by_index [DF_SCAN];
+ if (scan_dflow->problem_data)
+ {
+ bitmap blocks_to_reset = NULL;
+ int p;
+ for (p = df->num_problems_defined - 1; p >= 0 ;p--)
+ {
+ struct dataflow *dflow = df->problems_in_order[p];
+ if (*dflow->problem->reset_fun)
+ {
+ if (!blocks_to_reset)
+ {
+ basic_block bb;
+ blocks_to_reset = BITMAP_ALLOC (NULL);
+ FOR_ALL_BB(bb)
+ {
+ bitmap_set_bit (blocks_to_reset, bb->index);
+ }
+ }
+ (*dflow->problem->reset_fun) (dflow, blocks_to_reset);
+ }
+ }
+ if (blocks_to_reset)
+ BITMAP_FREE (blocks_to_reset);
+ }
+ df->blocks_to_analyze = BITMAP_ALLOC (NULL);
+ }
bitmap_copy (df->blocks_to_analyze, blocks);
}
else
DF_RU, /* Problem id. */
DF_BACKWARD, /* Direction. */
df_ru_alloc, /* Allocate the problem specific data. */
+ NULL, /* Reset global information. */
df_ru_free_bb_info, /* Free basic block info. */
df_ru_local_compute, /* Local compute function. */
df_ru_init_solution, /* Init the solution specific data. */
DF_RD, /* Problem id. */
DF_FORWARD, /* Direction. */
df_rd_alloc, /* Allocate the problem specific data. */
+ NULL, /* Reset global information. */
df_rd_free_bb_info, /* Free basic block info. */
df_rd_local_compute, /* Local compute function. */
df_rd_init_solution, /* Init the solution specific data. */
DF_LR, /* Problem id. */
DF_BACKWARD, /* Direction. */
df_lr_alloc, /* Allocate the problem specific data. */
+ NULL, /* Reset global information. */
df_lr_free_bb_info, /* Free basic block info. */
df_lr_local_compute, /* Local compute function. */
df_lr_init, /* Init the solution specific data. */
DF_UR, /* Problem id. */
DF_FORWARD, /* Direction. */
df_ur_alloc, /* Allocate the problem specific data. */
+ NULL, /* Reset global information. */
df_ur_free_bb_info, /* Free basic block info. */
df_ur_local_compute, /* Local compute function. */
df_ur_init, /* Init the solution specific data. */
DF_UREC, /* Problem id. */
DF_FORWARD, /* Direction. */
df_urec_alloc, /* Allocate the problem specific data. */
+ NULL, /* Reset global information. */
df_urec_free_bb_info, /* Free basic block info. */
df_urec_local_compute, /* Local compute function. */
df_urec_init, /* Init the solution specific data. */
}
+/* Reset all def_use and use_def chains in INSN. */
+
+static void
+df_chain_insn_reset (struct dataflow *dflow, rtx insn)
+{
+ struct df *df = dflow->df;
+ struct df_chain_problem_data *problem_data =
+ (struct df_chain_problem_data *) dflow->problem_data;
+ unsigned int uid = INSN_UID (insn);
+ struct df_insn_info *insn_info = NULL;
+ struct df_ref *ref;
+
+ if (uid < df->insns_size)
+ insn_info = DF_INSN_UID_GET (df, uid);
+
+ if (insn_info)
+ {
+ if (problem_data->flags & DF_DU_CHAIN)
+ {
+ ref = insn_info->defs;
+ while (ref)
+ {
+ ref->chain = NULL;
+ ref = ref->next_ref;
+ }
+ }
+
+ if (problem_data->flags & DF_UD_CHAIN)
+ {
+ ref = insn_info->uses;
+ while (ref)
+ {
+ ref->chain = NULL;
+ ref = ref->next_ref;
+ }
+ }
+ }
+}
+
+
+/* Reset all def_use and use_def chains in basic block. */
+
+static void
+df_chain_bb_reset (struct dataflow *dflow, unsigned int bb_index)
+{
+ struct df *df = dflow->df;
+ struct df_chain_problem_data *problem_data =
+ (struct df_chain_problem_data *) dflow->problem_data;
+ rtx insn;
+ basic_block bb = BASIC_BLOCK (bb_index);
+
+ /* Some one deleted the basic block out from under us. */
+ if (!bb)
+ return;
+
+ FOR_BB_INSNS (bb, insn)
+ {
+ if (INSN_P (insn))
+ {
+ /* Record defs within INSN. */
+ df_chain_insn_reset (dflow, insn);
+ }
+ }
+
+ /* Get rid of any chains in artifical uses or defs. */
+ if (problem_data->flags & DF_DU_CHAIN)
+ {
+ struct df_ref *def;
+ def = df_get_artificial_defs (df, bb_index);
+ while (def)
+ {
+ def->chain = NULL;
+ def = def->next_ref;
+ }
+ }
+
+ if (problem_data->flags & DF_UD_CHAIN)
+ {
+ struct df_ref *use;
+ use = df_get_artificial_uses (df, bb_index);
+ while (use)
+ {
+ use->chain = NULL;
+ use = use->next_ref;
+ }
+ }
+}
+
+
+/* Reset all of the chains when the set of basic blocks changes. */
+
+
+static void
+df_chain_reset (struct dataflow *dflow, bitmap blocks_to_clear)
+{
+ bitmap_iterator bi;
+ unsigned int bb_index;
+
+ EXECUTE_IF_SET_IN_BITMAP (blocks_to_clear, 0, bb_index, bi)
+ {
+ df_chain_bb_reset (dflow, bb_index);
+ }
+
+ free_alloc_pool (dflow->block_pool);
+ dflow->block_pool = NULL;
+}
+
+
/* Create the chains for a list of USEs. */
static void
DF_CHAIN, /* Problem id. */
DF_NONE, /* Direction. */
df_chain_alloc, /* Allocate the problem specific data. */
+ df_chain_reset, /* Reset global information. */
NULL, /* Free basic block info. */
NULL, /* Local compute function. */
NULL, /* Init the solution specific data. */
DF_RI, /* Problem id. */
DF_NONE, /* Direction. */
df_ri_alloc, /* Allocate the problem specific data. */
+ NULL, /* Reset global information. */
NULL, /* Free basic block info. */
df_ri_compute, /* Local compute function. */
NULL, /* Init the solution specific data. */
DF_SCAN, /* Problem id. */
DF_NONE, /* Direction. */
df_scan_alloc, /* Allocate the problem specific data. */
+ NULL, /* Reset global information. */
df_scan_free_bb_info, /* Free basic block info. */
NULL, /* Local compute function. */
NULL, /* Init the solution specific data. */
if (blocks)
{
+ int i;
+
/* Need to assure that there are space in all of the tables. */
unsigned int insn_num = get_max_uid () + 1;
insn_num += insn_num / 4;
df->def_info.add_refs_inline = true;
df->use_info.add_refs_inline = true;
+ for (i = df->num_problems_defined; i; i--)
+ {
+ bitmap blocks_to_reset = NULL;
+ if (*dflow->problem->reset_fun)
+ {
+ if (!blocks_to_reset)
+ {
+ blocks_to_reset = BITMAP_ALLOC (NULL);
+ bitmap_copy (blocks_to_reset, local_blocks_to_scan);
+ if (df->blocks_to_scan)
+ bitmap_ior_into (blocks_to_reset, df->blocks_to_scan);
+ }
+ (*dflow->problem->reset_fun) (dflow, blocks_to_reset);
+ }
+ if (blocks_to_reset)
+ BITMAP_FREE (blocks_to_reset);
+ }
+
df_refs_delete (dflow, local_blocks_to_scan);
/* This may be a mistake, but if an explicit blocks is passed in
{
struct df *df = dflow->df;
unsigned int uid = INSN_UID (insn);
- struct df_insn_info *insn_info = DF_INSN_UID_GET (df, uid);
+ struct df_insn_info *insn_info = NULL;
struct df_ref *ref;
struct df_scan_problem_data *problem_data =
(struct df_scan_problem_data *) dflow->problem_data;
+ if (uid < df->insns_size)
+ insn_info = DF_INSN_UID_GET (df, uid);
+
if (insn_info)
{
ref = insn_info->defs;
}
}
- /* Get rid of any artifical uses. */
+ /* Get rid of any artifical uses or defs. */
if (bb_info)
{
def = bb_info->artificial_defs;
/* Allocate the problem specific data. */
typedef void (*df_alloc_function) (struct dataflow *, bitmap);
+/* This function is called if the problem has global data that needs
+ to be cleared when ever the set of blocks changes. The bitmap
+ contains the set of blocks that may require special attention.
+ This call is only made if some of the blocks are going to change.
+ If everything is to be deleted, the wholesale deletion mechanisms
+ apply. */
+typedef void (*df_reset_function) (struct dataflow *, bitmap);
+
/* Free the basic block info. Called from the block reordering code
to get rid of the blocks that have been squished down. */
typedef void (*df_free_bb_function) (struct dataflow *, basic_block, void *);
unsigned int id;
enum df_flow_dir dir; /* Dataflow direction. */
df_alloc_function alloc_fun;
+ df_reset_function reset_fun;
df_free_bb_function free_bb_fun;
df_local_compute_function local_compute_fun;
df_init_function init_fun;
basic_block bb; /* Basic block containing the instruction. */
rtx insn; /* Insn containing ref. NB: THIS MAY BE NULL. */
rtx *loc; /* The location of the reg. */
- struct df_link *chain; /* Head of def-use, use-def or bi chain. */
+ struct df_link *chain; /* Head of def-use, use-def. */
unsigned int id; /* Location in table. */
enum df_ref_type type; /* Type of ref. */
enum df_ref_flags flags; /* Various flags. */
projects / thirdparty / gcc.git / commitdiff
