Here is an example of using the dataflow routines.
- df_[ru,rd,urec,ri,chain]_add_problem (flags);
+ df_[chain,live,note,rd]_add_problem (flags);
df_set_blocks (blocks);
df_finish_pass (false);
-DF_[ru,rd,urec,ri,chain]_ADD_PROBLEM adds a problem, defined by an
+DF_[chain,live,note,rd]_ADD_PROBLEM adds a problem, defined by an
instance to struct df_problem, to the set of problems solved in this
instance of df. All calls to add a problem for a given instance of df
must occur before the first call to DF_ANALYZE.
}
-/* Remove all of the problems that are not permanent. Scanning, lr,
- ur and live are permanent, the rest are removable. Also clear all
- of the changeable_flags. */
+/* Remove all of the problems that are not permanent. Scanning, LR
+ and (at -O2 or higher) LIVE are permanent, the rest are removable.
+ Also clear all of the changeable_flags. */
void
df_finish_pass (bool verify ATTRIBUTE_UNUSED)
\f
/*----------------------------------------------------------------------------
- COMBINED LIVE REGISTERS AND UNINITIALIZED REGISTERS.
-
- First find the set of uses for registers that are reachable from
- the entry block without passing thru a definition. In and out
- bitvectors are built for each basic block. The regnum is used to
- index into these sets. See df.h for details.
-
- Then the in and out sets here are the anded results of the in and
- out sets from the lr and ur
- problems.
+ LIVE AND MUST-INITIALIZED REGISTERS.
+
+ This problem first computes the IN and OUT bitvectors for the
+ must-initialized registers problems, which is a forward problem.
+ It gives the set of registers for which we MUST have an available
+ definition on any path from the entry block to the entry/exit of
+ a basic block. Sets generate a definition, while clobbers kill
+ a definition.
+
+ In and out bitvectors are built for each basic block and are indexed by
+ regnum (see df.h for details). In and out bitvectors in struct
+ df_live_bb_info actually refers to the must-initialized problem;
+
+ Then, the in and out sets for the LIVE problem itself are computed.
+ These are the logical AND of the IN and OUT sets from the LR problem
+ and the must-initialized problem.
----------------------------------------------------------------------------*/
/* Private data used to verify the solution for this problem. */
}
}
-/* Confluence function that ignores fake edges. */
+/* Forward confluence function that ignores fake edges. */
static void
df_live_confluence_n (edge e)
}
-/* Transfer function. */
+/* Transfer function for the forwards must-initialized problem. */
static bool
df_live_transfer_function (int bb_index)
}
-/* And the LR and UR info to produce the LIVE info. */
+/* And the LR info with the must-initialized registers, to produce the LIVE info. */
static void
df_live_local_finalize (bitmap all_blocks)
NULL, /* Debugging end block. */
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
-
- /* Technically this is only dependent on the live registers problem
- 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. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
struct df_link;
/* Data flow problems. All problems must have a unique id here. */
+
/* Scanning is not really a dataflow problem, but it is useful to have
the basic block functions in the vector so that things get done in
- a uniform manner. The first four problems are always defined. The
- last 5 are optional and can be added or deleted at any time. */
+ a uniform manner. The last four problems can be added or deleted
+ at any time are always defined (though LIVE is always there at -O2
+ or higher); the others are always there. */
#define DF_SCAN 0
#define DF_LR 1 /* Live Registers backward. */
#define DF_LIVE 2 /* Live Registers & Uninitialized Registers */