GCC Middle and Back End API Reference
df-core.cc File Reference
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "rtl.h"
#include "df.h"
#include "memmodel.h"
#include "emit-rtl.h"
#include "cfganal.h"
#include "tree-pass.h"
#include "cfgloop.h"
Include dependency graph for df-core.cc:

Functions

static void * df_get_bb_info (struct dataflow *, unsigned int)
 
static void df_set_bb_info (struct dataflow *, unsigned int, void *)
 
static void df_clear_bb_info (struct dataflow *, unsigned int)
 
void df_add_problem (const struct df_problem *problem)
 
int df_set_flags (int changeable_flags)
 
int df_clear_flags (int changeable_flags)
 
void df_set_blocks (bitmap blocks)
 
void df_remove_problem (struct dataflow *dflow)
 
void df_finish_pass (bool verify)
 
static unsigned int rest_of_handle_df_initialize (void)
 
rtl_opt_passmake_pass_df_initialize_opt (gcc::context *ctxt)
 
rtl_opt_passmake_pass_df_initialize_no_opt (gcc::context *ctxt)
 
static unsigned int rest_of_handle_df_finish (void)
 
rtl_opt_passmake_pass_df_finish (gcc::context *ctxt)
 
static bool df_worklist_propagate_forward (struct dataflow *dataflow, unsigned bb_index, unsigned *bbindex_to_postorder, bitmap worklist, bitmap pending, sbitmap considered, vec< int > &last_change_age, int age)
 
static bool df_worklist_propagate_backward (struct dataflow *dataflow, unsigned bb_index, unsigned *bbindex_to_postorder, bitmap worklist, bitmap pending, sbitmap considered, vec< int > &last_change_age, int age)
 
static void df_worklist_dataflow_doublequeue (struct dataflow *dataflow, bitmap pending, sbitmap considered, int *blocks_in_postorder, unsigned *bbindex_to_postorder, int n_blocks)
 
void df_worklist_dataflow (struct dataflow *dataflow, bitmap blocks_to_consider, int *blocks_in_postorder, int n_blocks)
 
static unsigned df_prune_to_subcfg (int list[], unsigned len, bitmap blocks)
 
void df_analyze_problem (struct dataflow *dflow, bitmap blocks_to_consider, int *postorder, int n_blocks)
 
static void df_analyze_1 (void)
 
void df_analyze (void)
 
static int loop_rev_post_order_compute (int *post_order, class loop *loop)
 
static int loop_inverted_rev_post_order_compute (int *post_order, class loop *loop)
 
void df_analyze_loop (class loop *loop)
 
int df_get_n_blocks (enum df_flow_dir dir)
 
int * df_get_postorder (enum df_flow_dir dir)
 
void df_simple_dataflow (enum df_flow_dir dir, df_init_function init_fun, df_confluence_function_0 con_fun_0, df_confluence_function_n con_fun_n, df_transfer_function trans_fun, bitmap blocks, int *postorder, int n_blocks)
 
void df_mark_solutions_dirty (void)
 
bool df_get_bb_dirty (basic_block bb)
 
void df_set_bb_dirty (basic_block bb)
 
void df_grow_bb_info (struct dataflow *dflow)
 
static void df_clear_bb_dirty (basic_block bb)
 
void df_compact_blocks (void)
 
void df_bb_replace (int old_index, basic_block new_block)
 
void df_bb_delete (int bb_index)
 
void df_verify (void)
 
df_ref df_bb_regno_first_def_find (basic_block bb, unsigned int regno)
 
df_ref df_bb_regno_last_def_find (basic_block bb, unsigned int regno)
 
df_ref df_bb_regno_only_def_find (basic_block bb, unsigned int regno)
 
df_ref df_find_def (rtx_insn *insn, rtx reg)
 
bool df_reg_defined (rtx_insn *insn, rtx reg)
 
df_ref df_find_use (rtx_insn *insn, rtx reg)
 
bool df_reg_used (rtx_insn *insn, rtx reg)
 
rtx df_find_single_def_src (rtx reg)
 
void dump_regset (regset r, FILE *outf)
 
void debug_regset (regset)
 
void df_print_regset (FILE *file, const_bitmap r)
 
void df_print_word_regset (FILE *file, const_bitmap r)
 
void df_dump (FILE *file)
 
void df_dump_region (FILE *file)
 
void df_dump_start (FILE *file)
 
static void df_dump_bb_problem_data (basic_block bb, FILE *file, bool top)
 
void df_dump_top (basic_block bb, FILE *file)
 
void df_dump_bottom (basic_block bb, FILE *file)
 
static void df_dump_insn_problem_data (const rtx_insn *insn, FILE *file, bool top)
 
void df_dump_insn_top (const rtx_insn *insn, FILE *file)
 
void df_dump_insn_bottom (const rtx_insn *insn, FILE *file)
 
static void df_ref_dump (df_ref ref, FILE *file)
 
void df_refs_chain_dump (df_ref ref, bool follow_chain, FILE *file)
 
void df_regs_chain_dump (df_ref ref, FILE *file)
 
static void df_mws_dump (struct df_mw_hardreg *mws, FILE *file)
 
static void df_insn_uid_debug (unsigned int uid, bool follow_chain, FILE *file)
 
DEBUG_FUNCTION void df_insn_debug (rtx_insn *insn, bool follow_chain, FILE *file)
 
DEBUG_FUNCTION void df_insn_debug_regno (rtx_insn *insn, FILE *file)
 
DEBUG_FUNCTION void df_regno_debug (unsigned int regno, FILE *file)
 
DEBUG_FUNCTION void df_ref_debug (df_ref ref, FILE *file)
 
DEBUG_FUNCTION void debug_df_insn (rtx_insn *insn)
 
DEBUG_FUNCTION void debug_df_reg (rtx reg)
 
DEBUG_FUNCTION void debug_df_regno (unsigned int regno)
 
DEBUG_FUNCTION void debug_df_ref (df_ref ref)
 
DEBUG_FUNCTION void debug_df_defno (unsigned int defno)
 
DEBUG_FUNCTION void debug_df_useno (unsigned int defno)
 
DEBUG_FUNCTION void debug_df_chain (struct df_link *link)
 

Variables

struct bitmap_obstack reg_obstack
 
bitmap_obstack df_bitmap_obstack
 
class df_ddf
 
static struct df_problem user_problem
 
static struct dataflow user_dflow
 

Function Documentation

◆ debug_df_chain()

DEBUG_FUNCTION void debug_df_chain ( struct df_link * link)

References df_chain_dump(), and fputc().

◆ debug_df_defno()

DEBUG_FUNCTION void debug_df_defno ( unsigned int defno)

References DF_DEFS_GET, and df_ref_debug().

◆ debug_df_insn()

DEBUG_FUNCTION void debug_df_insn ( rtx_insn * insn)
Functions for debugging from GDB.   

References debug_rtx(), df_insn_debug(), and df_insn_info::insn.

◆ debug_df_ref()

DEBUG_FUNCTION void debug_df_ref ( df_ref ref)

References df_ref_debug().

◆ debug_df_reg()

DEBUG_FUNCTION void debug_df_reg ( rtx reg)

References df_regno_debug(), and REGNO.

◆ debug_df_regno()

DEBUG_FUNCTION void debug_df_regno ( unsigned int regno)

References df_regno_debug().

◆ debug_df_useno()

DEBUG_FUNCTION void debug_df_useno ( unsigned int defno)

References df_ref_debug(), and DF_USES_GET.

◆ debug_regset()

DEBUG_FUNCTION void debug_regset ( regset r)
extern
Print a human-readable representation of R on the standard error
stream.  This function is designed to be used from within the
debugger.   

References dump_regset(), and r.

◆ df_add_problem()

◆ df_analyze()

◆ df_analyze_1()

◆ df_analyze_loop()

◆ df_analyze_problem()

void df_analyze_problem ( struct dataflow * dflow,
bitmap blocks_to_consider,
int * postorder,
int n_blocks )
Execute dataflow analysis on a single dataflow problem.

  BLOCKS_TO_CONSIDER are the blocks whose solution can either be
  examined or will be computed.  For calls from DF_ANALYZE, this is
  the set of blocks that has been passed to DF_SET_BLOCKS.

References df_problem::alloc_fun, dataflow::computed, df_problem::dataflow_fun, df_problem::finalize_fun, df_problem::local_compute_fun, dataflow::problem, timevar_pop(), timevar_push(), df_problem::tv_id, df_problem::verify_end_fun, and df_problem::verify_start_fun.

Referenced by df_analyze_1(), and fast_dce().

◆ df_bb_delete()

void df_bb_delete ( int bb_index)
Free all of the per basic block dataflow from all of the problems.
This is typically called before a basic block is deleted and the
problem will be reanalyzed.   

References BASIC_BLOCK_FOR_FN, cfun, df, df_clear_bb_dirty(), df_clear_bb_info(), df_get_bb_info(), df_mark_solutions_dirty(), df_problem::free_bb_fun, i, df_d::num_problems_defined, dataflow::problem, and df_d::problems_in_order.

Referenced by cfg_layout_merge_blocks(), rtl_delete_block(), and rtl_merge_blocks().

◆ df_bb_regno_first_def_find()

df_ref df_bb_regno_first_def_find ( basic_block bb,
unsigned int regno )
Return first def of REGNO within BB.   

References DF_REF_REGNO, FOR_BB_INSNS, FOR_EACH_INSN_DEF, INSN_P, and NULL.

Referenced by df_bb_regno_only_def_find().

◆ df_bb_regno_last_def_find()

df_ref df_bb_regno_last_def_find ( basic_block bb,
unsigned int regno )
Return last def of REGNO within BB.   

References DF_REF_REGNO, FOR_BB_INSNS_REVERSE, FOR_EACH_INSN_DEF, INSN_P, and NULL.

Referenced by df_bb_regno_only_def_find().

◆ df_bb_regno_only_def_find()

df_ref df_bb_regno_only_def_find ( basic_block bb,
unsigned int regno )
Return the one and only def of REGNO within BB.  If there is no def or
there are multiple defs, return NULL.   

References df_bb_regno_first_def_find(), df_bb_regno_last_def_find(), and NULL.

◆ df_bb_replace()

void df_bb_replace ( int old_index,
basic_block new_block )
Shove NEW_BLOCK in at OLD_INDEX.  Called from ifcvt to hack a
block.  There is no excuse for people to do this kind of thing.   

References BASIC_BLOCK_FOR_FN, dataflow::block_info, cfun, df, df_clear_bb_dirty(), df_get_bb_info(), df_grow_bb_info(), df_set_bb_dirty(), df_set_bb_info(), dump_file, gcc_assert, basic_block_def::index, NULL, df_d::num_problems_defined, df_d::problems_in_order, and SET_BASIC_BLOCK_FOR_FN.

Referenced by find_if_case_1().

◆ df_clear_bb_dirty()

static void df_clear_bb_dirty ( basic_block bb)
static
Clear the dirty bits.  This is called from places that delete
blocks.   

References bitmap_clear_bit(), df, basic_block_def::index, df_d::num_problems_defined, dataflow::out_of_date_transfer_functions, and df_d::problems_in_order.

Referenced by df_bb_delete(), and df_bb_replace().

◆ df_clear_bb_info()

static void df_clear_bb_info ( struct dataflow * dflow,
unsigned int index )
static

◆ df_clear_flags()

int df_clear_flags ( int changeable_flags)
Clear the MASK flags in the DFLOW problem.  The old flags are
returned.  If a flag is not allowed to be changed this will fail if
checking is enabled.   

References df_d::changeable_flags, and df.

Referenced by df_insn_rescan_all(), df_lr_dce_finalize(), df_process_deferred_rescans(), fast_dce(), if_convert(), ira(), run_fast_df_dce(), and run_word_dce().

◆ df_compact_blocks()

◆ df_dump()

void df_dump ( FILE * file)

◆ df_dump_bb_problem_data()

static void df_dump_bb_problem_data ( basic_block bb,
FILE * file,
bool top )
static

◆ df_dump_bottom()

void df_dump_bottom ( basic_block bb,
FILE * file )
Dump the bottom of the block information for BB.   

References df_dump_bb_problem_data().

Referenced by df_dump(), print_rtl_with_bb(), and rtl_dump_bb().

◆ df_dump_insn_bottom()

void df_dump_insn_bottom ( const rtx_insn * insn,
FILE * file )
Dump information about INSN after dumping INSN itself.   

References df_dump_insn_problem_data().

Referenced by print_rtl_with_bb(), and rtl_dump_bb().

◆ df_dump_insn_problem_data()

static void df_dump_insn_problem_data ( const rtx_insn * insn,
FILE * file,
bool top )
static

◆ df_dump_insn_top()

void df_dump_insn_top ( const rtx_insn * insn,
FILE * file )
Dump information about INSN before dumping INSN itself.   

References df_dump_insn_problem_data().

Referenced by print_rtl_with_bb(), and rtl_dump_bb().

◆ df_dump_region()

void df_dump_region ( FILE * file)
Dump dataflow info for df->blocks_to_analyze.   

References BASIC_BLOCK_FOR_FN, df_d::blocks_to_analyze, cfun, df, df_dump(), df_dump_start(), dump_bb(), EXECUTE_IF_SET_IN_BITMAP, and TDF_DETAILS.

Referenced by find_defs(), and iv_analysis_loop_init().

◆ df_dump_start()

◆ df_dump_top()

void df_dump_top ( basic_block bb,
FILE * file )
Dump the top of the block information for BB.   

References df_dump_bb_problem_data().

Referenced by df_dump(), print_rtl_with_bb(), and rtl_dump_bb().

◆ df_find_def()

df_ref df_find_def ( rtx_insn * insn,
rtx reg )
Finds the reference corresponding to the definition of REG in INSN.
DF is the dataflow object.   

References DF_REF_REGNO, FOR_EACH_INSN_DEF, gcc_assert, GET_CODE, NULL, REG_P, REGNO, and SUBREG_REG.

Referenced by biv_p(), df_reg_defined(), find_invariant_insn(), and iv_analyze_result().

◆ df_find_single_def_src()

rtx df_find_single_def_src ( rtx reg)

◆ df_find_use()

df_ref df_find_use ( rtx_insn * insn,
rtx reg )

◆ df_finish_pass()

◆ df_get_bb_dirty()

bool df_get_bb_dirty ( basic_block bb)
Return true if BB needs it's transfer functions recomputed.   

References bitmap_bit_p, df_live, df_lr, basic_block_def::index, and dataflow::out_of_date_transfer_functions.

Referenced by find_if_header(), if_convert(), and try_head_merge_bb().

◆ df_get_bb_info()

static void * df_get_bb_info ( struct dataflow * dflow,
unsigned int index )
static
Allocation for dataflow support routines.
   Copyright (C) 1999-2024 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)
             and Kenneth Zadeck (zadeck@naturalbridge.com).

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Get basic block info.   

References dataflow::block_info, df_problem::block_info_elt_size, dataflow::block_info_size, NULL, and dataflow::problem.

Referenced by df_bb_delete(), df_bb_replace(), and df_set_blocks().

◆ df_get_n_blocks()

int df_get_n_blocks ( enum df_flow_dir dir)
Return the number of basic blocks from the last call to df_analyze.   

References df, DF_FORWARD, DF_NONE, gcc_assert, df_d::n_blocks, df_d::postorder, and df_d::postorder_inverted.

Referenced by calculate_global_remat_bb_data(), dse_step4(), ext_dce(), fast_dce(), and lra_create_live_ranges_1().

◆ df_get_postorder()

int * df_get_postorder ( enum df_flow_dir dir)
Return a pointer to the array of basic blocks in the reverse postorder.
Depending on the direction of the dataflow problem,
it returns either the usual reverse postorder array
or the reverse postorder of inverted traversal.  

References df, DF_FORWARD, DF_NONE, gcc_assert, df_d::postorder, and df_d::postorder_inverted.

Referenced by calculate_global_remat_bb_data(), dse_step4(), ext_dce(), fast_dce(), and lra_create_live_ranges_1().

◆ df_grow_bb_info()

◆ df_insn_debug()

DEBUG_FUNCTION void df_insn_debug ( rtx_insn * insn,
bool follow_chain,
FILE * file )

◆ df_insn_debug_regno()

◆ df_insn_uid_debug()

static void df_insn_uid_debug ( unsigned int uid,
bool follow_chain,
FILE * file )
static

◆ df_mark_solutions_dirty()

◆ df_mws_dump()

static void df_mws_dump ( struct df_mw_hardreg * mws,
FILE * file )
static

◆ df_print_regset()

◆ df_print_word_regset()

void df_print_word_regset ( FILE * file,
const_bitmap r )
Write information about registers and basic blocks into FILE.  The
bitmap is in the form used by df_byte_lr.  This is part of making a
debugging dump.   

References bitmap_bit_p, i, max_reg_num(), NULL, and r.

Referenced by df_word_lr_bottom_dump(), df_word_lr_top_dump(), and word_dce_process_block().

◆ df_prune_to_subcfg()

static unsigned df_prune_to_subcfg ( int list[],
unsigned len,
bitmap blocks )
static
Remove the entries not in BLOCKS from the LIST of length LEN, preserving
the order of the remaining entries.  Returns the length of the resulting
list.   

References bitmap_bit_p, and last.

Referenced by df_analyze().

◆ df_ref_debug()

◆ df_ref_dump()

static void df_ref_dump ( df_ref ref,
FILE * file )
static

◆ df_refs_chain_dump()

void df_refs_chain_dump ( df_ref ref,
bool follow_chain,
FILE * file )

◆ df_reg_defined()

bool df_reg_defined ( rtx_insn * insn,
rtx reg )
Return true if REG is defined in INSN, zero otherwise.   

References df_find_def(), and NULL.

◆ df_reg_used()

bool df_reg_used ( rtx_insn * insn,
rtx reg )
Return true if REG is referenced in INSN, zero otherwise.   

References df_find_use(), and NULL.

◆ df_regno_debug()

DEBUG_FUNCTION void df_regno_debug ( unsigned int regno,
FILE * file )

◆ df_regs_chain_dump()

void df_regs_chain_dump ( df_ref ref,
FILE * file )
Dump either a ref-def or reg-use chain.   

References df_ref_dump(), and DF_REF_NEXT_REG.

Referenced by df_regno_debug().

◆ df_remove_problem()

◆ df_set_bb_dirty()

◆ df_set_bb_info()

static void df_set_bb_info ( struct dataflow * dflow,
unsigned int index,
void * bb_info )
static

◆ df_set_blocks()

◆ df_set_flags()

◆ df_simple_dataflow()

void df_simple_dataflow ( enum df_flow_dir dir,
df_init_function init_fun,
df_confluence_function_0 con_fun_0,
df_confluence_function_n con_fun_n,
df_transfer_function trans_fun,
bitmap blocks,
int * postorder,
int n_blocks )
Interface for calling iterative dataflow with user defined
confluence and transfer functions.  All that is necessary is to
supply DIR, a direction, CONF_FUN_0, a confluence function for
blocks with no logical preds (or NULL), CONF_FUN_N, the normal
confluence function, TRANS_FUN, the basic block transfer function,
and BLOCKS, the set of blocks to examine, POSTORDER the blocks in
postorder, and N_BLOCKS, the number of blocks in POSTORDER.  

References df_problem::con_fun_0, df_problem::con_fun_n, df_worklist_dataflow(), df_problem::dir, df_problem::init_fun, dataflow::problem, df_problem::trans_fun, user_dflow, and user_problem.

Referenced by calculate_global_remat_bb_data(), dse_step4(), ext_dce(), and lra_create_live_ranges_1().

◆ df_verify()

void df_verify ( void )
Verify that there is a place for everything and everything is in
its place.  This is too expensive to run after every pass in the
mainline.  However this is an excellent debugging tool if the
dataflow information is not being updated properly.  You can just
sprinkle calls in until you find the place that is changing an
underlying structure without calling the proper updating
routine.   

References df_d::changeable_flags, df, df_live, df_live_verify_transfer_functions(), df_lr_verify_transfer_functions(), and df_scan_verify().

Referenced by df_analyze_1().

◆ df_worklist_dataflow()

void df_worklist_dataflow ( struct dataflow * dataflow,
bitmap blocks_to_consider,
int * blocks_in_postorder,
int n_blocks )
Worklist-based dataflow solver. It uses sbitmap as a worklist,
with "n"-th bit representing the n-th block in the reverse-postorder order.
The solver is a double-queue algorithm similar to the "double stack" solver
from Cooper, Harvey and Kennedy, "Iterative data-flow analysis, Revisited".
The only significant difference is that the worklist in this implementation
is always sorted in RPO of the CFG visiting direction.   

References BITMAP_ALLOC, bitmap_clear(), bitmap_set_bit, cfun, df_bitmap_obstack, DF_NONE, df_worklist_dataflow_doublequeue(), df_problem::dir, EXECUTE_IF_SET_IN_BITMAP, free(), gcc_assert, i, df_problem::init_fun, last_basic_block_for_fn, and dataflow::problem.

Referenced by df_lr_dce_finalize(), and df_simple_dataflow().

◆ df_worklist_dataflow_doublequeue()

static void df_worklist_dataflow_doublequeue ( struct dataflow * dataflow,
bitmap pending,
sbitmap considered,
int * blocks_in_postorder,
unsigned * bbindex_to_postorder,
int n_blocks )
static
Main dataflow solver loop.

DATAFLOW is problem we are solving, PENDING is worklist of basic blocks we
need to visit.
BLOCK_IN_POSTORDER is array of size N_BLOCKS specifying postorder in BBs and
BBINDEX_TO_POSTORDER is array mapping back BB->index to postorder position.
PENDING will be freed.

The worklists are bitmaps indexed by postorder positions.  

The function implements standard algorithm for dataflow solving with two
worklists (we are processing WORKLIST and storing new BBs to visit in
PENDING).

As an optimization we maintain ages when BB was changed (stored in
last_change_age) and when it was last visited (stored in last_visit_age).
This avoids need to re-do confluence function for edges to basic blocks
whose source did not change since destination was visited last time.   

References BITMAP_ALLOC, bitmap_clear_first_set_bit(), bitmap_empty_p(), BITMAP_FREE, cfun, changed, df_bitmap_obstack, DF_FORWARD, df_worklist_propagate_backward(), df_worklist_propagate_forward(), df_problem::dir, dump_file, n_basic_blocks_for_fn, n_edges_for_fn, dataflow::problem, vNULL, and worklist.

Referenced by df_worklist_dataflow().

◆ df_worklist_propagate_backward()

static bool df_worklist_propagate_backward ( struct dataflow * dataflow,
unsigned bb_index,
unsigned * bbindex_to_postorder,
bitmap worklist,
bitmap pending,
sbitmap considered,
vec< int > & last_change_age,
int age )
static

◆ df_worklist_propagate_forward()

static bool df_worklist_propagate_forward ( struct dataflow * dataflow,
unsigned bb_index,
unsigned * bbindex_to_postorder,
bitmap worklist,
bitmap pending,
sbitmap considered,
vec< int > & last_change_age,
int age )
static
Helper function for df_worklist_dataflow.
Propagate the dataflow forward.
Given a BB_INDEX, do the dataflow propagation
and set bits on for successors in PENDING for earlier
and WORKLIST for later in bbindex_to_postorder
if the out set of the dataflow has changed.

AGE specify time when BB was visited last time.
AGE of 0 means we are visiting for first time and need to
compute transfer function to initialize datastructures.
Otherwise we re-do transfer function only if something change
while computing confluence functions.
We need to compute confluence only of basic block that are younger
then last visit of the BB.

Return true if BB info has changed.  This is always the case
in the first visit.   

References BASIC_BLOCK_FOR_FN, bitmap_bit_p, bitmap_set_bit, cfun, changed, df_problem::con_fun_0, df_problem::con_fun_n, EDGE_COUNT, FOR_EACH_EDGE, basic_block_def::preds, dataflow::problem, basic_block_def::succs, df_problem::trans_fun, and worklist.

Referenced by df_worklist_dataflow_doublequeue().

◆ dump_regset()

void dump_regset ( regset r,
FILE * outf )
Write information about registers and basic blocks into FILE.
This is part of making a debugging dump.   

References EXECUTE_IF_SET_IN_REG_SET, i, NULL, r, and reg_names.

Referenced by debug_regset(), and dump_candidates_and_remat_bb_data().

◆ loop_inverted_rev_post_order_compute()

static int loop_inverted_rev_post_order_compute ( int * post_order,
class loop * loop )
static
Compute the reverse top sort order of the inverted sub-CFG specified
by LOOP.  Returns the number of blocks which is always loop->num_nodes.   

References bitmap_set_bit, EDGE_COUNT, ei_edge(), ei_next(), ei_one_before_end_p(), ei_start, flow_bb_inside_loop_p(), free(), loop::header, basic_block_def::index, loop::num_nodes, basic_block_def::preds, and visited.

Referenced by df_analyze_loop().

◆ loop_rev_post_order_compute()

static int loop_rev_post_order_compute ( int * post_order,
class loop * loop )
static
Compute the reverse top sort order of the sub-CFG specified by LOOP.
Returns the number of blocks which is always loop->num_nodes.   

References bitmap_set_bit, EDGE_COUNT, ei_edge(), ei_next(), ei_one_before_end_p(), ei_start, flow_bb_inside_loop_p(), free(), basic_block_def::index, loop_preheader_edge(), loop::num_nodes, basic_block_def::succs, and visited.

Referenced by df_analyze_loop().

◆ make_pass_df_finish()

rtl_opt_pass * make_pass_df_finish ( gcc::context * ctxt)

◆ make_pass_df_initialize_no_opt()

rtl_opt_pass * make_pass_df_initialize_no_opt ( gcc::context * ctxt)

◆ make_pass_df_initialize_opt()

rtl_opt_pass * make_pass_df_initialize_opt ( gcc::context * ctxt)

◆ rest_of_handle_df_finish()

static unsigned int rest_of_handle_df_finish ( void )
static
Free all the dataflow info and the DF structure.  This should be
called from the df_finish macro which also NULLs the parm.   

References bitmap_obstack_release(), df, df_bitmap_obstack, free(), df_problem::free_fun, gcc_assert, df_d::hard_regs_live_count, i, NULL, df_d::num_problems_defined, df_d::postorder, df_d::postorder_inverted, dataflow::problem, and df_d::problems_in_order.

◆ rest_of_handle_df_initialize()

Variable Documentation

◆ df

class df_d* df
This is used for debugging and for the dumpers to find the latest
instance so that the df info can be added to the dumps.  This
should not be used by regular code.   

Referenced by compact_blocks(), create_task_copyfn(), decompose_multiword_subregs(), df_add_problem(), df_add_refs_to_table(), df_analyze(), df_analyze_1(), df_analyze_loop(), df_bb_delete(), df_bb_refs_collect(), df_bb_refs_record(), df_bb_replace(), df_chain_bb_dump(), df_chain_create_bb(), df_chain_create_bb_process_use(), df_chain_insn_bottom_dump(), df_chain_insn_top_dump(), df_clear_bb_dirty(), df_clear_flags(), df_compact_blocks(), df_compute_regs_ever_live(), df_count_refs(), df_dump_bb_problem_data(), df_dump_insn_problem_data(), df_dump_region(), df_dump_start(), df_entry_block_bitmap_verify(), df_exit_block_bitmap_verify(), df_find_use(), df_finish_pass(), df_get_call_refs(), df_get_n_blocks(), df_get_postorder(), df_grow_insn_info(), df_grow_reg_info(), df_hard_reg_used_count(), df_hard_reg_used_p(), df_insn_change_bb(), df_insn_delete(), df_insn_info_delete(), df_insn_rescan(), df_insn_rescan_all(), df_insn_rescan_debug_internal(), df_install_ref(), df_install_ref_incremental(), df_install_refs(), df_live_verify_transfer_functions(), df_lr_confluence_0(), df_lr_confluence_n(), df_lr_dce_finalize(), df_lr_local_compute(), df_lr_verify_transfer_functions(), df_mark_solutions_dirty(), df_maybe_reorganize_def_refs(), df_maybe_reorganize_use_refs(), df_md_bb_local_compute(), df_md_bb_local_compute_process_def(), df_md_simulate_one_insn(), df_notes_rescan(), df_process_deferred_rescans(), df_rd_bb_local_compute(), df_rd_bb_local_compute_process_def(), df_rd_dump_defs_set(), df_rd_local_compute(), df_rd_simulate_one_insn(), df_rd_start_dump(), df_rd_transfer_function(), df_ref_change_reg_with_loc(), df_ref_create_structure(), df_ref_record(), df_refs_add_to_chains(), df_reg_chain_unlink(), df_remove_problem(), df_reorganize_refs_by_insn(), df_reorganize_refs_by_reg(), df_reorganize_refs_by_reg_by_insn(), df_reorganize_refs_by_reg_by_reg(), df_scan_alloc(), df_scan_blocks(), df_scan_free(), df_scan_free_internal(), df_scan_start_dump(), df_scan_verify(), df_set_bb_dirty(), df_set_blocks(), df_set_flags(), df_set_regs_ever_live(), df_simulate_fixup_sets(), df_update_entry_block_defs(), df_update_exit_block_uses(), df_verify(), df_word_lr_local_compute(), dump_reg_info(), fast_dce(), find_invariants_to_move(), glibc_linux_libm_function_max_error(), ira(), latch_dominating_def(), print_rtl_with_bb(), reginfo_init(), remove_edge_and_dominated_blocks(), remove_reg_equal_equiv_notes_for_regno(), rest_of_handle_df_finish(), rest_of_handle_df_initialize(), and rtl_dump_bb().

◆ df_bitmap_obstack

◆ reg_obstack

◆ user_dflow

struct dataflow user_dflow
static

Referenced by df_simple_dataflow().

◆ user_problem

struct df_problem user_problem
static

Referenced by df_simple_dataflow().