In
computer science, control-flow analysis (CFA) is a
static-code-analysis technique for determining the
control flow of a program. The control flow is expressed as a
control-flow graph (CFG). For both
functional programming languages and
object-oriented programming languages, the term CFA, and elaborations such as ''k''-CFA, refer to specific algorithms that compute control flow.
For many
imperative programming languages, the control flow of a program is explicit in a program's source code. As a result,
interprocedural control-flow analysis implicitly usually refers to a
static analysis technique for determining the receiver(s) of function or method calls in computer programs written in a
higher-order programming language. For example, in a programming language with
higher-order functions like
Scheme, the target of a function call may not be explicit: in the isolated expression
(lambda (f) (f x))
it is unclear to which procedure
f may refer. A control-flow analysis must consider where this expression could be invoked and what argument it may receive to determine the possible targets.
Techniques such as
abstract interpretation
In computer science, abstract interpretation is a theory of sound approximation of the semantics of computer programs, based on monotonic functions over ordered sets, especially lattices. It can be viewed as a partial execution of a computer prog ...
,
constraint solving, and
type systems may be used for control-flow analysis.
See also
*
Control-flow diagram (CFD)
*
Data-flow analysis
*
Cartesian product algorithm
In mathematics, specifically set theory, the Cartesian product of two sets ''A'' and ''B'', denoted ''A''×''B'', is the set of all ordered pairs where ''a'' is in ''A'' and ''b'' is in ''B''. In terms of set-builder notation, that is
: A\ ...
*
Pointer analysis
References
External links
{{Commonscat, Control-flow analysis
for textbook intraprocedural CFA in imperative languagesCFA in functional programs (survey)for the relationship between CFA analysis in functional languages and points-to analysis in imperative/OOP languages