Control-flow analysis

Compiler technique

This article may need to be rewritten to comply with Wikipedia's quality standards. You can help. The talk page may contain suggestions. (July 2014)

|

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.[dubious - discuss]

For many imperative programming languages, the control flow of a program is explicit in a program's source code.[dubious - discuss] As a result, interprocedural control-flow analysis implicitly usually refers to a static analysis technique for determining the receivers of function or method calls in computer programs written in a higher-order programming language.[dubious - discuss] 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, constraint solving, and type systems may be used for control-flow analysis.[1][page needed]

## See also

[edit]

* Control-flow diagram (CFD)
* Data-flow analysis
* Cartesian product algorithm
* Pointer analysis

## References

[edit]

1. ^ Nielson, Flemming; Nielson, Hanne Riis; Hankin, Chris (2005). Principles of Program Analysis. Springer Science+Business Media.

## External links

[edit]

Wikimedia Commons has media related to Control-flow analysis.

* for textbook intraprocedural CFA in imperative languages
* CFA in functional programs (survey)
* for the relationship between CFA analysis in functional languages and points-to analysis in imperative/OOP languages

* v
* t
* e

Compiler optimizations

Basic block|

* Peephole optimization
* Local value numbering

Loop|

* Automatic parallelization
* Automatic vectorization
* Induction variable
* Loop fusion
* Loop-invariant code motion
* Loop inversion
* Loop interchange
* Loop nest optimization
* Loop splitting
* Loop unrolling
* Loop unswitching
* Software pipelining
* Strength reduction

Data-flow
analysis|

* Available expression
* Common subexpression elimination
* Constant folding
* Dead store elimination
* Induction variable recognition and elimination
* Live-variable analysis
* Upwards exposed uses
* Use-define chain
* Reaching definitions

SSA-based|

* Global value numbering
* Sparse conditional constant propagation

Code generation|

* Instruction scheduling
* Instruction selection
* Register allocation
* Rematerialization

Functional|

* Deforestation
* Tail-call elimination

Global|

* Interprocedural optimization

Other|

* Bounds-checking elimination
* Compile-time function execution
* Dead-code elimination
* Expression templates
* Inline expansion
* Jump threading
* Partial evaluation
* Profile-guided optimization

Static analysis|

* Alias analysis
* Array-access analysis
* Control-flow analysis
* Data-flow analysis
* Dependence analysis
* Escape analysis
* Pointer analysis
* Shape analysis
* Value range analysis

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template