+<<<<<<< .mine
+2007-06-15 Kenneth Zadeck <zadeck@naturalbridge.com>
+
+ * df.h (DF_FIRST_OPTIONAL_PROBLEM): Removed.
+ (struct df_problem.free_blocks_on_set_blocks): New field.
+ (struct dataflow.optional_p): New field.
+ (df_bb_regno_last_use_find, df_insn_regno_def_p): Removed.
+ (df_live_set_all_dirty): New function.
+ * df-scan.c (df_scan_alloc): Initialize optional_p.
+ (problem_SCAN): Initialize free_blocks_on_set_blocks.
+ * df-core.c (df_set_blocks): Removed use of
+ DF_FIRST_OPTIONAL_PROBLEM. Now uses
+ df_problem.free_blocks_on_set_blocks to determine which blocks are
+ recycled.
+ (df_remove_problem): Removed use of DF_FIRST_OPTIONAL_PROBLEM.
+ (df_finish_pass): Removed use of DF_FIRST_OPTIONAL_PROBLEM. Now
+ uses dataflow.optional_p to determine if problem should be
+ deleted.
+ (rest_of_handle_df_initialize): Only start live problem if
+ -02 or above.
+ (df_bb_regno_last_use_find, df_insn_regno_def_p): Removed.
+ * df-problems.c (df_ru_alloc, df_rd_alloc, df_lr_alloc,
+ df_live_alloc, df_urec_alloc, df_note_alloc): set optional_p.
+ (problem_RU, problem_RD, problem_LR, problem_UREC, problem_CHAIN,
+ problem_NOTE): Initialize free_blocks_on_set_blocks.
+ (df_lr_bb_local_compute): Recompute luids if df_live problem is
+ not active.
+ (df_live_set_all_dirty, df_note_alloc): New function.
+ * regrename.c (merge_overlapping_regs): Change DF_LIVE_* to
+ df_get_live_*.
+ * sched_ebb.c (compute_jump_reg_dependencies): Ditto.
+ * postreload.c (reload_combine): Ditto.
+ * cse.c (cse_extended_basic_block): Ditto.
+ * regmove.c (mark_flags_life_zones): Ditto.
+ * rtlfactoring.c (split_blocks_after_seqs, split_pattern_seq,
+ erase_matching_seqs): Ditto.
+ * bt-load.c (compute_defs_uses_and_gen): Ditto.
+ * integrate (allocate_initial_values): Ditto.
+ * combine.c (reg_dead_at_p): Ditto.
+ * resource.c (mark_target_live_regs): Ditto.
+ * sched-rgn.c (check_live_1, update_live_1): Ditto.
+ * config/sh/sh.c (find_r0_life_regions): Ditto.
+ * global.c (rest_of_handle_global_alloc): Only add back df_live
+ for -O > 1.
+ * local-alloc.c (rest_of_handle_local_alloc): Only remove
+ df_live for -O > 1.
+ * ifcvt.c (dead_or_predicable): Change DF_LIVE_* to
+ df_get_live_*.
+ (if_convert): Make sure df_live is there at -O == 1.
+ (pass_if_after_combine): Cleanup flags.
+ * init-regs.c (initialize_uninitialized_regs): Make sure df_live
+ is there at -O == 1.
+
+=======
2007-06-19 Seongbae Park <seongbae.park@gmail.com>
* config/arm/arm.c (arm_get_frame_offsets): Set
* config/frv/frv.c (frv_ifcvt_modify_tests): Dataflow merge fix.
(frv_ifcvt_modify_insn): Likewise.
+>>>>>>> .r125856
2007-06-19 Richard Guenther <rguenther@suse.de>
* tree-ssa-structalias.c (handle_ptr_arith): Make sure to
* df-scan.c (df_get_exit-block_use_set): Always add the stack pointer
to the exit block use set.
+ (df_insn_delete, df_insn_rescan): Fixed spelling of "deferring".
* gcse.c (cpro_jump): Don't emit barrier in cfglayout mode.
* config/sparc/sparc.c (sparc_check_64): Check df != NULL.
CLEAR_HARD_REG_SET (info.btrs_written_in_block);
for (reg = first_btr; reg <= last_btr; reg++)
if (TEST_HARD_REG_BIT (all_btrs, reg)
- && REGNO_REG_SET_P (DF_LIVE_IN (bb), reg))
+ && REGNO_REG_SET_P (df_get_live_in (bb), reg))
SET_HARD_REG_BIT (info.btrs_live_in_block, reg);
for (insn = BB_HEAD (bb), last = NEXT_INSN (BB_END (bb));
COPY_HARD_REG_SET (btrs_live[i], info.btrs_live_in_block);
COPY_HARD_REG_SET (btrs_written[i], info.btrs_written_in_block);
- REG_SET_TO_HARD_REG_SET (btrs_live_at_end[i], DF_LIVE_OUT (bb));
+ REG_SET_TO_HARD_REG_SET (btrs_live_at_end[i], df_get_live_out (bb));
/* If this block ends in a jump insn, add any uses or even clobbers
of branch target registers that it might have. */
for (insn = BB_END (bb); insn != BB_HEAD (bb) && ! INSN_P (insn); )
}
for (i = reg_dead_regno; i < reg_dead_endregno; i++)
- if (REGNO_REG_SET_P (DF_LIVE_IN (block), i))
+ if (REGNO_REG_SET_P (df_get_live_in (block), i))
return 0;
return 1;
int set;
int death = 0;
- if (REGNO_REG_SET_P (DF_LIVE_IN (b), R0_REG))
+ if (REGNO_REG_SET_P (df_get_live_in (b), R0_REG))
{
set = 1;
live = 1;
qty_table = XNEWVEC (struct qty_table_elem, max_qty);
new_basic_block ();
- cse_ebb_live_in = DF_LIVE_IN (ebb_data->path[0].bb);
- cse_ebb_live_out = DF_LIVE_OUT (ebb_data->path[path_size - 1].bb);
+ cse_ebb_live_in = df_get_live_in (ebb_data->path[0].bb);
+ cse_ebb_live_out = df_get_live_out (ebb_data->path[path_size - 1].bb);
for (path_entry = 0; path_entry < path_size; path_entry++)
{
basic_block bb;
bitmap_print (dump_file, blocks, "setting blocks to analyze ", "\n");
if (df->blocks_to_analyze)
{
+ /* This block is called to change the focus from one subset
+ to another. */
int p;
bitmap diff = BITMAP_ALLOC (&df_bitmap_obstack);
bitmap_and_compl (diff, df->blocks_to_analyze, blocks);
- for (p = df->num_problems_defined - 1; p >= DF_FIRST_OPTIONAL_PROBLEM ;p--)
+ for (p = 0; p < df->num_problems_defined; p++)
{
struct dataflow *dflow = df->problems_in_order[p];
- if (dflow->problem->reset_fun)
+ if (dflow->optional_p && dflow->problem->reset_fun)
dflow->problem->reset_fun (df->blocks_to_analyze);
- else if (dflow->problem->free_bb_fun)
+ else if (dflow->problem->free_blocks_on_set_blocks)
{
bitmap_iterator bi;
unsigned int bb_index;
}
else
{
- /* If we have not actually run scanning before, do not try
- to clear anything. */
- if (df_scan->problem_data)
+ /* This block of code is executed to change the focus from
+ the entire function to a subset. */
+ bitmap blocks_to_reset = NULL;
+ int p;
+ for (p = 0; p < df->num_problems_defined; p++)
{
- bitmap blocks_to_reset = NULL;
- int p;
- for (p = df->num_problems_defined - 1; p >= DF_FIRST_OPTIONAL_PROBLEM ;p--)
+ struct dataflow *dflow = df->problems_in_order[p];
+ if (dflow->optional_p && dflow->problem->reset_fun)
{
- struct dataflow *dflow = df->problems_in_order[p];
- if (dflow->problem->reset_fun)
+ if (!blocks_to_reset)
{
- if (!blocks_to_reset)
+ basic_block bb;
+ blocks_to_reset =
+ BITMAP_ALLOC (&df_bitmap_obstack);
+ FOR_ALL_BB(bb)
{
- basic_block bb;
- blocks_to_reset =
- BITMAP_ALLOC (&df_bitmap_obstack);
- FOR_ALL_BB(bb)
- {
- bitmap_set_bit (blocks_to_reset, bb->index);
- }
+ bitmap_set_bit (blocks_to_reset, bb->index);
}
- dflow->problem->reset_fun (blocks_to_reset);
}
+ dflow->problem->reset_fun (blocks_to_reset);
}
- if (blocks_to_reset)
- BITMAP_FREE (blocks_to_reset);
}
+ if (blocks_to_reset)
+ BITMAP_FREE (blocks_to_reset);
+
df->blocks_to_analyze = BITMAP_ALLOC (&df_bitmap_obstack);
}
bitmap_copy (df->blocks_to_analyze, blocks);
}
else
{
+ /* This block is executed to reset the focus to the entire
+ function. */
if (dump_file)
- fprintf (dump_file, "clearing blocks to analyze\n");
+ fprintf (dump_file, "clearing blocks_to_analyze\n");
if (df->blocks_to_analyze)
{
BITMAP_FREE (df->blocks_to_analyze);
{
struct df_problem *problem;
int i;
- int start = 0;
if (!dflow)
return;
problem = dflow->problem;
gcc_assert (problem->remove_problem_fun);
- /* Normally only optional problems are removed, but during global,
- we remove ur and live and replace it with urec. */
- if (problem->id >= DF_FIRST_OPTIONAL_PROBLEM)
- start = DF_FIRST_OPTIONAL_PROBLEM;
-
/* Delete any problems that depended on this problem first. */
- for (i = start; i < df->num_problems_defined; i++)
+ for (i = 0; i < df->num_problems_defined; i++)
if (df->problems_in_order[i]->problem->dependent_problem == problem)
df_remove_problem (df->problems_in_order[i]);
/* Now remove this problem. */
- for (i = start; i < df->num_problems_defined; i++)
+ for (i = 0; i < df->num_problems_defined; i++)
if (df->problems_in_order[i] == dflow)
{
int j;
saved_flags = df->changeable_flags;
#endif
- for (i = DF_FIRST_OPTIONAL_PROBLEM; i < df->num_problems_defined; i++)
+ for (i = 0; i < df->num_problems_defined; i++)
{
struct dataflow *dflow = df->problems_in_order[i];
struct df_problem *problem = dflow->problem;
- gcc_assert (problem->remove_problem_fun);
- (problem->remove_problem_fun) ();
- df->problems_in_order[i] = NULL;
- df->problems_by_index[problem->id] = NULL;
- removed++;
+ if (dflow->optional_p)
+ {
+ gcc_assert (problem->remove_problem_fun);
+ (problem->remove_problem_fun) ();
+ df->problems_in_order[i] = NULL;
+ df->problems_by_index[problem->id] = NULL;
+ removed++;
+ }
}
df->num_problems_defined -= removed;
/* These three problems are permanent. */
df_lr_add_problem ();
- if (optimize)
+ if (optimize > 1)
df_live_add_problem ();
df->postorder = XNEWVEC (int, last_basic_block);
----------------------------------------------------------------------------*/
-/* Return last use of REGNO within BB. */
-
-struct df_ref *
-df_bb_regno_last_use_find (basic_block bb, unsigned int regno)
-{
- rtx insn;
- struct df_ref **use_rec;
- unsigned int uid;
-
- FOR_BB_INSNS_REVERSE (bb, insn)
- {
- if (!INSN_P (insn))
- continue;
-
- uid = INSN_UID (insn);
- for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
- {
- struct df_ref *use = *use_rec;
- if (DF_REF_REGNO (use) == regno)
- return use;
- }
-
- if (df->changeable_flags & DF_EQ_NOTES)
- for (use_rec = DF_INSN_UID_EQ_USES (uid); *use_rec; use_rec++)
- {
- struct df_ref *use = *use_rec;
- if (DF_REF_REGNO (use) == regno)
- return use;
- }
- }
- return NULL;
-}
-
-
/* Return first def of REGNO within BB. */
struct df_ref *
return NULL;
}
-/* Return true if INSN defines REGNO. */
-
-bool
-df_insn_regno_def_p (rtx insn, unsigned int regno)
-{
- unsigned int uid;
- struct df_ref **def_rec;
-
- uid = INSN_UID (insn);
- for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
- {
- struct df_ref *def = *def_rec;
- if (DF_REF_REGNO (def) == regno)
- return true;
- }
-
- return false;
-}
-
-
/* Finds the reference corresponding to the definition of REG in INSN.
DF is the dataflow object. */
bb_info->out = BITMAP_ALLOC (&problem_data->ru_bitmaps);
}
}
+ df_ru->optional_p = true;
}
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verfiy end. */
NULL, /* Dependent problem. */
- TV_DF_RU /* Timing variable. */
+ TV_DF_RU, /* Timing variable. */
+ true /* Reset blocks on dropping out of blocks_to_analyze. */
};
bb_info->out = BITMAP_ALLOC (&problem_data->rd_bitmaps);
}
}
+ df_rd->optional_p = true;
}
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verfiy end. */
NULL, /* Dependent problem. */
- TV_DF_RD /* Timing variable. */
+ TV_DF_RD, /* Timing variable. */
+ true /* Reset blocks on dropping out of blocks_to_analyze. */
};
bb_info->ause = NULL;
}
}
+
+ df_lr->optional_p = false;
}
}
}
#endif
+
+ /* If the df_live problem is not defined, such as at -O0 and -O1, we
+ still need to keep the luids up to date. This is normally done
+ in the df_live problem since this problem has a forwards
+ scan. */
+ if (!df_live)
+ df_recompute_luids (bb);
}
df_lr_verify_solution_start,/* Incremental solution verify start. */
df_lr_verify_solution_end, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
- TV_DF_LR /* Timing variable. */
+ TV_DF_LR, /* Timing variable. */
+ false /* Reset blocks on dropping out of blocks_to_analyze. */
};
bb_info->out = BITMAP_ALLOC (NULL);
}
}
+ df_live->optional_p = (optimize <= 1);
}
df_live_verify_solution_start,/* Incremental solution verify start. */
df_live_verify_solution_end, /* Incremental solution verify end. */
&problem_LR, /* Dependent problem. */
- TV_DF_LIVE /* Timing variable. */
+ TV_DF_LIVE, /* Timing variable. */
+ false /* Reset blocks on dropping out of blocks_to_analyze. */
};
}
+/* Set all of the blocks as dirty. This needs to be done if this
+ problem is added after all of the insns have been scanned. */
+
+void
+df_live_set_all_dirty (void)
+{
+ basic_block bb;
+ FOR_ALL_BB (bb)
+ bitmap_set_bit (df_live->out_of_date_transfer_functions,
+ bb->index);
+}
+
+
/* Verify that all of the lr related info is consistent and
correct. */
bb_info->earlyclobber = BITMAP_ALLOC (NULL);
}
}
+ df_urec->optional_p = true;
}
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verfiy end. */
&problem_LR, /* Dependent problem. */
- TV_DF_UREC /* Timing variable. */
+ TV_DF_UREC, /* Timing variable. */
+ false /* Reset blocks on dropping out of blocks_to_analyze. */
};
df_chain_remove_problem ();
df_chain->block_pool = create_alloc_pool ("df_chain_block pool",
sizeof (struct df_link), 50);
+ df_chain->optional_p = true;
}
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verfiy end. */
&problem_RD, /* Dependent problem. */
- TV_DF_CHAIN /* Timing variable. */
+ TV_DF_CHAIN, /* Timing variable. */
+ false /* Reset blocks on dropping out of blocks_to_analyze. */
};
This pass computes REG_DEAD and REG_UNUSED notes.
----------------------------------------------------------------------------*/
+static void
+df_note_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
+{
+ df_note->optional_p = true;
+}
+
#ifdef REG_DEAD_DEBUGGING
static void
df_print_note (const char *prefix, rtx insn, rtx note)
{
DF_NOTE, /* Problem id. */
DF_NONE, /* Direction. */
- NULL, /* Allocate the problem specific data. */
+ df_note_alloc, /* Allocate the problem specific data. */
NULL, /* Reset global information. */
NULL, /* Free basic block info. */
df_note_compute, /* Local compute function. */
but it will produce information if built one of uninitialized
register problems (UR, UREC) is also run. */
&problem_LR, /* Dependent problem. */
- TV_DF_NOTE /* Timing variable. */
+ TV_DF_NOTE, /* Timing variable. */
+ false /* Reset blocks on dropping out of blocks_to_analyze. */
};
df->insns_to_delete = BITMAP_ALLOC (&problem_data->insn_bitmaps);
df->insns_to_rescan = BITMAP_ALLOC (&problem_data->insn_bitmaps);
df->insns_to_notes_rescan = BITMAP_ALLOC (&problem_data->insn_bitmaps);
+ df_scan->optional_p = false;
}
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verfiy end. */
NULL, /* Dependent problem. */
- TV_DF_SCAN /* Timing variable. */
+ TV_DF_SCAN, /* Timing variable. */
+ false /* Reset blocks on dropping out of blocks_to_analyze. */
};
#define DF_NOTE 7 /* REG_DEF and REG_UNUSED notes. */
#define DF_LAST_PROBLEM_PLUS1 (DF_NOTE + 1)
-#define DF_FIRST_OPTIONAL_PROBLEM DF_RU
/* Dataflow direction. */
enum df_flow_dir
df_verify_solution_start verify_start_fun;
df_verify_solution_end verify_end_fun;
struct df_problem *dependent_problem;
+
/* The timevar id associated with this pass. */
unsigned int tv_id;
+
+ /* True if the df_set_blocks should null out the basic block info if
+ this block drops out of df->blocks_to_analyze. */
+ bool free_blocks_on_set_blocks;
};
solutions. Note that this bit is always true for all problems except
lr and live. */
bool solutions_dirty;
+
+ /* If true, this pass is deleted by df_finish_pass. This is never
+ true for DF_SCAN and DF_LR. It is true for DF_LIVE if optimize >
+ 1. It is always true for the other problems. */
+ bool optional_p;
};
#ifdef DF_DEBUG_CFG
extern void df_check_cfg_clean (void);
#endif
-extern struct df_ref *df_bb_regno_last_use_find (basic_block, unsigned int);
extern struct df_ref *df_bb_regno_first_def_find (basic_block, unsigned int);
extern struct df_ref *df_bb_regno_last_def_find (basic_block, unsigned int);
-extern bool df_insn_regno_def_p (rtx, unsigned int);
extern struct df_ref *df_find_def (rtx, rtx);
extern bool df_reg_defined (rtx, rtx);
extern struct df_ref *df_find_use (rtx, rtx);
extern void df_lr_verify_transfer_functions (void);
extern void df_live_verify_transfer_functions (void);
extern void df_live_add_problem (void);
+extern void df_live_set_all_dirty (void);
extern void df_urec_add_problem (void);
extern void df_chain_add_problem (enum df_chain_flags);
extern void df_note_add_problem (void);
going to help here because it does not touch the artificial uses
and defs. */
df_finish_pass ();
- if (optimize)
+ if (optimize > 1)
df_live_add_problem ();
df_scan_alloc (NULL);
df_scan_blocks ();
/* The loop below takes the set of live registers
after JUMP, and calculates the live set before EARLIEST. */
- bitmap_copy (test_live, DF_LIVE_IN (other_bb));
+ bitmap_copy (test_live, df_get_live_in (other_bb));
df_simulate_artificial_refs_at_end (test_bb, test_live);
for (insn = jump; ; insn = prev)
{
if (bitmap_intersect_p (test_set, merge_set)
|| bitmap_intersect_p (test_live, merge_set)
- || bitmap_intersect_p (test_set, DF_LIVE_IN (merge_bb)))
+ || bitmap_intersect_p (test_set, df_get_live_in (merge_bb)))
fail = 1;
BITMAP_FREE (merge_set);
basic_block bb;
int pass;
+ if (optimize == 1)
+ {
+ df_live_add_problem ();
+ df_live_set_all_dirty ();
+ }
+
num_possible_if_blocks = 0;
num_updated_if_blocks = 0;
num_true_changes = 0;
num_true_changes);
}
+ if (optimize == 1)
+ df_remove_problem (df_live);
+
#ifdef ENABLE_CHECKING
verify_flow_info ();
#endif
static bool
gate_handle_if_after_reload (void)
{
- return (optimize > 0);
+ return (optimize > 0 && flag_if_conversion2);
}
static unsigned int
rest_of_handle_if_after_reload (void)
{
- if (flag_if_conversion2)
- if_convert (true);
+ if_convert (true);
return 0;
}
basic_block bb;
bitmap already_genned = BITMAP_ALLOC (NULL);
+ if (optimize == 1)
+ {
+ df_live_add_problem ();
+ df_live_set_all_dirty ();
+ }
+
df_analyze ();
FOR_EACH_BB (bb)
}
}
+ if (optimize == 1)
+ df_remove_problem (df_live);
+
BITMAP_FREE (already_genned);
}
/* Update global register liveness information. */
FOR_EACH_BB (bb)
{
- if (REGNO_REG_SET_P(DF_LIVE_IN (bb), regno))
- SET_REGNO_REG_SET (DF_LIVE_IN (bb), new_regno);
- if (REGNO_REG_SET_P(DF_LIVE_OUT (bb), regno))
- SET_REGNO_REG_SET (DF_LIVE_OUT (bb), new_regno);
+ if (REGNO_REG_SET_P(df_get_live_in (bb), regno))
+ SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
+ if (REGNO_REG_SET_P(df_get_live_out (bb), regno))
+ SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);
}
}
}
int max_regno = max_reg_num ();
df_note_add_problem ();
+
+ if (optimize > 1)
+ df_remove_problem (df_live);
+ /* Create a new version of df that has the special version of UR if
+ we are doing optimization. */
if (optimize)
- {
- /* Create a new version of df that has the special version of UR
- if we are doing optimization. */
- df_remove_problem (df_live);
- df_urec_add_problem ();
- }
+ df_urec_add_problem ();
df_analyze ();
regstat_init_n_sets_and_refs ();
regstat_compute_ri ();
if (LABEL_P (insn))
{
HARD_REG_SET live;
+ bitmap live_in = df_get_live_in (bb);
- REG_SET_TO_HARD_REG_SET (live, DF_LIVE_IN (bb));
- compute_use_by_pseudos (&live, DF_LIVE_IN (bb));
+ REG_SET_TO_HARD_REG_SET (live, live_in);
+ compute_use_by_pseudos (&live, live_in);
COPY_HARD_REG_SET (LABEL_LIVE (insn), live);
IOR_HARD_REG_SET (ever_live_at_start, live);
}
{
int i;
for (i = 0; i < flags_nregs; ++i)
- live |= REGNO_REG_SET_P (DF_LIVE_IN (block), flags_regno + i);
+ live |= REGNO_REG_SET_P (df_get_live_in (block), flags_regno + i);
}
#endif
rtx insn;
HARD_REG_SET live;
- REG_SET_TO_HARD_REG_SET (live, DF_LIVE_IN (b));
+ REG_SET_TO_HARD_REG_SET (live, df_get_live_in (b));
insn = BB_HEAD (b);
while (t)
{
TARGET. Otherwise, we must assume everything is live. */
if (b != -1)
{
- regset regs_live = DF_LIVE_IN (BASIC_BLOCK (b));
+ regset regs_live = df_get_live_in (BASIC_BLOCK (b));
rtx start_insn, stop_insn;
reg_set_iterator rsi;
for (mseq = sb->matching_seqs; mseq; mseq = mseq->next_matching_seq)
{
block_label_after (mseq->insn);
- IOR_REG_SET (DF_LIVE_OUT (BLOCK_FOR_INSN (pattern_seqs->insn)),
- DF_LIVE_OUT (BLOCK_FOR_INSN (mseq->insn)));
+ IOR_REG_SET (df_get_live_out (BLOCK_FOR_INSN (pattern_seqs->insn)),
+ df_get_live_out (BLOCK_FOR_INSN (mseq->insn)));
}
}
}
gen_symbol_ref_rtx_for_label
(retlabel)), BB_END (bb));
/* Update liveness info. */
- SET_REGNO_REG_SET (DF_LIVE_OUT (bb),
+ SET_REGNO_REG_SET (df_get_live_out (bb),
REGNO (pattern_seqs->link_reg));
}
BB_END (bb) = callinsn;
/* Maintain control flow and liveness information. */
- SET_REGNO_REG_SET (DF_LIVE_OUT (bb),
+ SET_REGNO_REG_SET (df_get_live_out (bb),
REGNO (pattern_seqs->link_reg));
emit_barrier_after (BB_END (bb));
make_single_succ_edge (bb, BLOCK_FOR_INSN (sb->label), 0);
- IOR_REG_SET (DF_LIVE_OUT (bb),
- DF_LIVE_IN (BLOCK_FOR_INSN (sb->label)));
+ IOR_REG_SET (df_get_live_out (bb),
+ df_get_live_in (BLOCK_FOR_INSN (sb->label)));
make_edge (BLOCK_FOR_INSN (seq_blocks->label),
BLOCK_FOR_INSN (retlabel), EDGE_ABNORMAL);
it may guard the fallthrough block from using a value that has
conditionally overwritten that of the main codepath. So we
consider that it restores the value of the main codepath. */
- bitmap_and (set, DF_LIVE_IN (e->dest), cond_set);
+ bitmap_and (set, df_get_live_in (e->dest), cond_set);
else
- bitmap_ior_into (used, DF_LIVE_IN (e->dest));
+ bitmap_ior_into (used, df_get_live_in (e->dest));
}
/* Used in schedule_insns to initialize current_sched_info for scheduling
gcc_assert (!t || (CONTAINING_RGN (b->index)
!= CONTAINING_RGN (BB_TO_BLOCK (src))));
- if (t || REGNO_REG_SET_P (DF_LIVE_IN (b), regno + j))
+ if (t || REGNO_REG_SET_P (df_get_live_in (b), regno + j))
return 0;
}
}
gcc_assert (!t || (CONTAINING_RGN (b->index)
!= CONTAINING_RGN (BB_TO_BLOCK (src))));
- if (t || REGNO_REG_SET_P (DF_LIVE_IN (b), regno))
+ if (t || REGNO_REG_SET_P (df_get_live_in (b), regno))
return 0;
}
}
{
basic_block b = candidate_table[src].update_bbs.first_member[i];
- SET_REGNO_REG_SET (DF_LIVE_IN (b), regno + j);
+ SET_REGNO_REG_SET (df_get_live_in (b), regno + j);
}
}
}
{
basic_block b = candidate_table[src].update_bbs.first_member[i];
- SET_REGNO_REG_SET (DF_LIVE_IN (b), regno);
+ SET_REGNO_REG_SET (df_get_live_in (b), regno);
}
}
}
projects / thirdparty / gcc.git / commitdiff
