View source for Data-flow analysis

{{Short description|Method of analyzing variables in software}}
{{About|static program analysis|dynamic program analysis|Dynamic program analysis#Dynamic data-flow analysis}}
{{More citations needed section|date=February 2018}}
{{Use dmy dates|date=January 2020|cs1-dates=y}}
{{Software development process}}
'''Data-flow analysis''' is a technique for gathering information about the possible set of values calculated at various points in a [[computer program]]. A program's [[control-flow graph]] (CFG) is used to determine those parts of a program to which a particular value assigned to a variable might propagate. The information gathered is often used by [[compiler]]s when [[optimizing compiler|optimizing]] a program. A canonical example of a data-flow analysis is [[reaching definitions]].

A simple way to perform data-flow analysis of programs is to set up data-flow equations for each [[node (computer science)|node]] of the control-flow graph and solve them by repeatedly calculating the output from the input locally at each node until the whole system stabilizes, i.e., it reaches a [[fixpoint]]. {{anchor|Kildall's method}}This general approach, also known as ''Kildall's method''<!-- or ''Kildall's algorithm'' -->, was developed by [[Gary Kildall]] while teaching at the [[Naval Postgraduate School]].<ref name="Kildall_1972_Optimization"/><ref name="Kildall_1973_Optimization"/><ref name="Cortesi_1999"/><ref name="Laws_2014_IEEE"/>

== Basic principles ==
Data-flow analysis is the process of collecting information about the way the variables are defined and used in the program. It attempts to obtain particular information at each point in a procedure. Usually, it is enough to obtain this information at the boundaries of [[basic block]]s, since from that it is easy to compute the information at points in the basic block. In forward flow analysis, the exit state of a block is a function of the block's entry state. This function is the composition of the effects of the statements in the block. The entry state of a block is a function of the exit states of its predecessors. This yields a set of data-flow equations:

For each block b:

: <math> out_b = trans_b (in_b) </math>
: <math> in_b = join_{p \in pred_b}(out_p) </math>

In this, <math> trans_b </math> is the '''transfer function''' of the block <math>b</math>. It works on the entry state <math>in_b</math>, yielding the exit state <math>out_b</math>. The [[Join (mathematics)|join operation]] <math>join</math> combines the exit states of the predecessors <math>p \in pred_b</math> of <math>b</math>, yielding the entry state of <math>b</math>.

After solving this set of equations, the entry and/or exit states of the blocks can be used to derive properties of the program at the block boundaries. The transfer function of each statement separately can be applied to get information at a point inside a basic block.

Each particular type of data-flow analysis has its own specific transfer function and join operation. Some data-flow problems require backward flow analysis. This follows the same plan, except that the transfer function is applied to the exit state yielding the entry state, and the join operation works on the entry states of the successors to yield the exit state.

The [[entry point]] (in forward flow) plays an important role: Since it has no predecessors, its entry state is well defined at the start of the analysis. For instance, the set of local variables with known values is empty. If the control-flow graph does not contain cycles (there were no explicit or implicit [[Control flow#Loops|loops]] in the procedure) solving the equations is straightforward. The control-flow graph can then be [[topological sort|topologically sorted]]; running in the order of this sort, the entry states can be computed at the start of each block, since all predecessors of that block have already been processed, so their exit states are available. If the control-flow graph does contain cycles, a more advanced algorithm is required.

== An iterative algorithm ==
The most common way of solving the data-flow equations is by using an iterative algorithm. It starts with an approximation of the in-state of each block. The out-states are then computed by applying the transfer functions on the in-states. From these, the in-states are updated by applying the join operations. The latter two steps are repeated until we reach the so-called '''fixpoint''': the situation in which the in-states (and the out-states in consequence) do not change.
 
A basic algorithm for solving data-flow equations is the '''round-robin iterative algorithm''':
:for ''i'' ← 1 to ''N''
::''initialize node i''
:while (''sets are still changing'')
::for ''i'' ← 1 to ''N''
:::''recompute sets at node i''

=== Convergence ===
To be usable, the iterative approach should actually reach a fixpoint. This can be guaranteed
by imposing constraints on the combination of the value domain of the states, the transfer functions and the join operation.

The value domain should be a [[partial order]] with '''finite height''' (i.e., there are no infinite ascending chains <math>x_1</math> < <math>x_2</math> < ...).  The combination of the transfer function and the join operation should be [[monotonic]] with respect to this partial order.  Monotonicity ensures that on each iteration the value will either stay the same or will grow larger, while finite height ensures that it cannot grow indefinitely.  Thus we will ultimately reach a situation where T(x) = x for all x, which is the fixpoint.

=== The work list approach ===
It is easy to improve on the algorithm above by noticing that the in-state of a block will not change if the out-states of its predecessors don't change. Therefore, we introduce a '''work list''': a list of blocks that still need to be processed. Whenever the out-state of a block changes, we add its successors to the work list. In each iteration, a block is removed from the work list. Its out-state is computed. If the out-state changed, the block's successors are added to the work list. For efficiency, a block should not be in the work list more than once.

The algorithm is started by putting information-generating blocks in the work list. It terminates when the
work list is empty.

=== Ordering ===
The efficiency of iteratively solving data-flow equations is influenced by the order at which local nodes are visited.<ref name="Cooper_2004"/> Furthermore, it depends on whether the data-flow equations are used for forward or backward data-flow analysis over the CFG. Intuitively, in a forward flow problem, it would be fastest if all predecessors of a block have been processed before the block itself, since then the iteration will use the latest information. In the absence of loops it is possible to order the blocks in such a way that the correct out-states are computed by processing each block only once.

In the following, a few iteration orders for solving data-flow equations are discussed 
(a related concept to iteration order of a [[control-flow graph|CFG]] is [[tree traversal]] of a
[[Tree (graph theory)|tree]]).

* '''Random order''' - This iteration order is not aware whether the data-flow equations solve a forward or backward data-flow problem. Therefore, the performance is relatively poor compared to specialized iteration orders.
* '''[[Postorder]]''' - This is a typical iteration order for backward data-flow problems. In ''postorder iteration'', a node is visited after all its successor nodes have been visited. Typically, the ''postorder iteration'' is implemented with the '''depth-first''' strategy.
* '''[[depth-first search#Vertex orderings|Reverse postorder]]''' - This is a typical iteration order for forward data-flow problems. In '''reverse-postorder iteration''', a node is visited before any of its successor nodes has been visited, except when the successor is reached by a back edge. (Note that reverse postorder is not the same as [[depth-first search#Vertex orderings|preorder]].)

=== Initialization ===
The initial value of the in-states is important to obtain correct and accurate results. 
If the results are used for compiler optimizations, they should provide '''conservative''' information, i.e. when applying the information, the program should not change semantics. 
The iteration of the fixpoint algorithm will take the values in the direction of the maximum element. Initializing all blocks with the maximum element is therefore not useful. At least one block starts in a state with a value less than the maximum. The details depend on the
data-flow problem. If the minimum element represents totally conservative information, the results can be used safely even during the data-flow iteration. If it represents the most accurate information, fixpoint should be reached before the results can be applied.

== Examples ==
The following are examples of properties of computer programs that can be calculated by data-flow analysis.
Note that the properties calculated by data-flow analysis are typically only approximations of the real
properties. This is because data-flow analysis operates on the syntactical structure of the CFG without
simulating the exact control flow of the program.
However, to be still useful in practice, a data-flow analysis algorithm is typically designed to calculate 
an upper respectively lower approximation of the real program properties.

=== Forward analysis ===
The [[reaching definition]] analysis calculates for each program point the set of definitions that 
may potentially reach this program point.

<syntaxhighlight lang="text" line highlight="2,4,7">
  if b == 4 then
     a = 5;
  else 
     a = 3;
  endif
 
  if a < 4 then
     ...
</syntaxhighlight>
The reaching definition of variable {{code|a}} at line 7 is the set of assignments {{code|1=a = 5}} at line 2 and {{code|1=a = 3}} at line 4.

=== Backward analysis ===
The [[live variable analysis]] calculates for each program point the variables that may be 
potentially read afterwards before their next write update. The result is typically used by
[[dead code elimination]] to remove statements that assign to a variable whose value is not used afterwards.

The in-state of a block is the set of variables that are live at the start of it. It initially contains all variables live (contained) in the block, before the transfer function is applied and the actual contained values are computed. The transfer function of a statement is applied by killing the variables that are written within this block (remove them from the set of live variables). The out-state of a block is the set of variables that are live at the end of the block and is computed by the union of the block's successors' in-states.

Initial code:

{{col-begin|width=auto}}
{{col-break}}
 b1: a = 3; 
     b = 5;
     d = 4;
     x = 100;
     if a > b then
 b2:    c = a + b;
        d = 2;
 b3: endif
     c = 4;
     return b * d + c;
{{col-end}}

Backward analysis:

{{col-begin|width=auto}}
{{col-break}}
 // in: {}
 b1: a = 3; 
     b = 5;
     d = 4;
     x = 100; //x is never being used later thus not in the out set {a,b,d}
     if a > b then
 // out: {a,b,d}    //union of all (in) successors of b1 => b2: {a,b}, and b3:{b,d}  
 
 // in: {a,b}
 b2: c = a + b;
     d = 2;
 // out: {b,d}
 
 // in: {b,d}
 b3: endif
     c = 4;
     return b * d + c;
 // out:{}
{{col-end}}

The in-state of b3 only contains ''b'' and ''d'', since ''c'' has been written. The out-state of b1 is the union of the in-states of b2 and b3. The definition of ''c'' in b2 can be removed, since ''c'' is not live immediately after the statement.

Solving the data-flow equations starts with initializing all in-states and out-states to the empty set. The work list is initialized by inserting the exit point (b3) in the work list (typical for backward flow). Its computed in-state differs from the previous one, so its predecessors b1 and b2 are inserted and the process continues. The progress is summarized in the table below.

{| class="wikitable"
|-
! processing
! out-state
! old in-state 
! new in-state
! work list
|-
| b3
| {}
| {}
| {b,d}
| (b1,b2)
|-
| b1
| {b,d}
| {}
| {}
| (b2)
|-
| b2
| {b,d}
| {}
| {a,b}
| (b1)
|-
| b1
| {a,b,d}
| {}
| {}
| ()
|}

Note that b1 was entered in the list before b2, which forced processing b1 twice (b1 was re-entered as predecessor of b2). Inserting b2 before b1 would have allowed earlier completion.

Initializing with the empty set is an optimistic initialization: all variables start out as dead. Note that the out-states cannot shrink from one iteration to the next, although the out-state can be smaller than the in-state. This can be seen from the fact that after the first iteration the out-state can only change by a change of the in-state. Since the in-state starts as the empty set, it can only grow in further iterations.

== Other approaches ==
Several modern compilers use [[static single-assignment form]] as the method for analysis of variable dependencies. <ref>{{cite web |title=Static Single Assignment (with relevant examples) |url=https://www.geeksforgeeks.org/static-single-assignment-with-relevant-examples/ |website=GeeksforGeeks |access-date=2023-08-16 |language=en-us |date=2 October 2021}}</ref>

In 2002, Markus Mohnen described a new method of data-flow analysis that does not require the explicit construction of a data-flow graph,<ref name="Mohnen_2002"/> instead relying on [[abstract interpretation]] of the program and keeping a working set of program counters. At each conditional branch, both targets are added to the working set. Each path is followed for as many instructions as possible (until end of program or until it has looped with no changes), and then removed from the set and the next program counter retrieved.

A combination of [[control flow analysis]] and data flow analysis has shown to be useful and complementary in identifying cohesive source code regions implementing functionalities of a system (e.g., [[Software feature|features]], [[requirement]]s or [[use case]]s).<ref name="Kuang_2015"/>

== Special classes of problems ==
There are a variety of special classes of dataflow problems which have efficient or general solutions.

=== Bit vector problems ===
The examples above are problems in which the data-flow value is a set, e.g. the set of [[reaching definitions]] (Using a bit for a definition position in the program), or the set of live variables. These sets can be represented efficiently as '''[[Bit array|bit vectors]]''', in which each bit represents set membership of one particular element. Using this representation, the join and transfer functions can be implemented as bitwise logical operations. The join operation is typically union or intersection, implemented by bitwise ''logical or'' and ''logical and''.
The transfer function for each block can be decomposed in so-called ''gen'' and ''kill'' sets.

As an example, in live-variable analysis, the join operation is union. The ''kill'' set is the set of variables that are written in a block, whereas the ''gen'' set is the set of variables that are read without being written first. The data-flow equations become

:<math> out_b = \bigcup_{s \in succ_b} in_s </math>

:<math> in_b = (out_b - kill_b) \cup gen_b </math>

In logical operations, this reads as

 out(''b'') = 0
 '''for''' ''s'' '''in''' succ(''b'')
     out(''b'') = out(''b'') '''or''' in(''s'')
 in(''b'') = (out(''b'') '''and not''' kill(''b'')) '''or''' gen(''b'')

Dataflow problems which have sets of data-flow values which can be represented as bit vectors are called '''bit vector problems''', '''gen-kill problems''', or '''locally separable problems'''.<ref name="Reps_1995"/> Such problems have generic polynomial-time solutions.<ref name="Knoop_1996"/>

In addition to the reaching definitions and live variables problems mentioned above, the following problems are instances of bitvector problems:<ref name="Knoop_1996"/>
* [[Available expression]]s
* Very busy expressions
* [[Use-define chain|Use-definition chains]]

=== IFDS problems ===
'''Interprocedural, finite, distributive, subset problems''' or '''IFDS''' problems are another class of problem with a generic polynomial-time solution.<ref name="Reps_1995"/><ref name="Naeem_2010"/> Solutions to these problems provide context-sensitive and flow-sensitive dataflow analyses.

There are several implementations of IFDS-based dataflow analyses for popular programming languages, e.g. in the Soot<ref name="Bodden_2012"/> and WALA<ref name="Rapoport_2015"/> frameworks for Java analysis.

Every bitvector problem is also an IFDS problem, but there are several significant IFDS problems that are not bitvector problems, including truly-live variables and possibly-uninitialized variables.

== Sensitivities ==
{{main|Polyvariance}}

Data-flow analysis is typically path-insensitive, though it is possible to define data-flow equations that yield a path-sensitive analysis.

* A '''flow-sensitive''' analysis takes into account the order of statements in a program.  For example, a flow-insensitive pointer alias analysis may determine "variables ''x'' and ''y'' may refer to the same location", while a flow-sensitive analysis may determine "after statement 20, variables ''x'' and ''y'' may refer to the same location".
* A '''path-sensitive''' analysis computes different pieces of analysis information dependent on the predicates at conditional branch instructions. For instance, if a branch contains a condition {{code|x>0}}, then on the ''fall-through'' path, the analysis would assume that {{code|1=x<=0}} and on the target of the branch it would assume that indeed {{code|x>0}} holds.
* A '''context-sensitive''' analysis is an ''interprocedural'' analysis that considers the calling context when analyzing the target of a function call. In particular, using context information one can ''jump back'' to the original call site, whereas without that information, the analysis information has to be propagated back to all possible call sites, potentially losing precision.

== List of data-flow analyses ==
* [[Reaching definitions]]
* [[Liveness analysis]]
* [[Definite assignment analysis]]
* [[Available expression]]
* [[Constant propagation]]

==See also==
* [[Abstract interpretation]]
* [[Control flow analysis]]
* [[XLT86]]

==References==
{{reflist|refs=
<ref name="Kildall_1972_Optimization">{{Cite book |title=Global expression optimization during compilation |author-first=Gary Arlen |author-last=Kildall |author-link=Gary Arlen Kildall |type=Ph.D. dissertation |publisher=[[University of Washington]], Computer Science Group |location=Seattle, Washington, USA |date=May 1972<!-- Technical Report: June 1972 --> |id=Thesis No. 20506, Technical Report No. 72-06-02}}</ref>
<ref name="Kildall_1973_Optimization">{{cite journal |author-first=Gary Arlen |author-last=Kildall |author-link=Gary Kildall |date=1973-10-01 |title=A Unified Approach to Global Program Optimization |journal=Proceedings of the 1st Annual ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages (POPL) |series=POPL '73 |location=Boston, Massachusetts, USA |pages=194–206 |doi=10.1145/512927.512945 |hdl=10945/42162 |s2cid=10219496 |url=http://static.aminer.org/pdf/PDF/000/546/451/a_unified_approach_to_global_program_optimization.pdf |access-date=2006-11-20 |url-status=live |archive-url=https://web.archive.org/web/20170629213307/http://static.aminer.org/pdf/PDF/000/546/451/a_unified_approach_to_global_program_optimization.pdf |archive-date=2017-06-29}} ([http://portal.acm.org/citation.cfm?id=512945&coll=portal&dl=ACM])</ref>
<ref name="Cortesi_1999">{{cite book |title=Static Analysis: 6th International Symposium, SAS'99, Venice, Italy, September 22–24, 1999, Proceedings |chapter=Optimization: Detecting Equalities of Variables, Combining Efficiency with Precision |author-first1=Oliver |author-last1=Rüthing |author-first2=Jens |author-last2=Knoop |author-first3=Bernhard |author-last3=Steffen |author-link3=Bernhard Steffen (computer scientist) |series=Lecture Notes in Computer Science |volume=1694 |editor-first1=Agostino |editor-last1=Cortesi |editor-first2=Gilberto |editor-last2=Filé |edition=illustrated |publisher=Springer |date=2003-07-31 |orig-year=1999 |issn=0302-9743 |isbn=9783540664598  |pages=232–247 [233<!-- relevant page -->] |chapter-url=https://books.google.com/books?id=ZwxqCQAAQBAJ&pg=PA233}}</ref>
<ref name="Laws_2014_IEEE">{{cite web |title=Legacy of Gary Kildall: The CP/M IEEE Milestone Dedication |author-first1=Robert |author-last1=Huitt |author-first2=Gordon |author-last2=Eubanks |author-link2=Gordon Eubanks |author-first3=Thomas "Tom" Alan |author-last3=Rolander |author-link3=Thomas Alan Rolander |author-first4=David |author-last4=Laws |author-first5=Howard E. |author-last5=Michel |author-first6=Brian |author-last6=Halla |author-first7=John Harrison |author-last7=Wharton |author-link7=John Harrison Wharton |author-first8=Brian |author-last8=Berg |author-first9=Weilian |author-last9=Su |author-first10=Scott |author-last10=Kildall |author-link10=Scott Kildall |author-first11=Bill |author-last11=Kampe |editor-first=David |editor-last=Laws |date=2014-04-25 |location=Pacific Grove, California, USA |type=video transscription |id=CHM Reference number: X7170.2014 |publisher=[[Computer History Museum]] |url=https://archive.computerhistory.org/resources/access/text/2014/06/102746909-05-01-acc.pdf |access-date=2020-01-19 |quote=[…] [[Gordon Eubanks|Eubanks]]: […] [[Gary Arlen Kildall|Gary]] […] was an inventor, he was inventive, he did things. His Ph.D. thesis proved that global flow analysis converges. […] This is a fundamental idea in computer science. […] I took a […] summer course once from a guy named [[Dhananjay M. Dhamdhere|Dhamdhere]] […] they talked about optimization for like a week and then they put a slide up and said, "Kildall's Method," this is the real story. […] that's something that no one ever thinks about. […]}} [https://ethw.org/Milestones:The_CP/M_Microcomputer_Operating_System,_1974][https://www.youtube.com/watch?v=HO6IPpL0y8g] (33 pages)</ref>
<ref name="Cooper_2004">{{cite web |author-first1=Keith D. |author-last1=Cooper |author-link1=Keith D. Cooper |author-first2=Timothy J. |author-last2=Harvey |author-first3=Ken |author-last3=Kennedy |author-link3=Ken Kennedy (computer scientist) |title=Iterative Data-Flow Analysis, Revisited |work=PLDI 2003 |date=2004-03-26 |orig-year=November 2002 |publisher=[[Association for Computing Machinery|ACM]] |id=TR04-432 |url=https://www.cs.rice.edu/uploadedFiles/Computer_Science/Research/Tech_Reports/2004/TR04-432.pdf |access-date=2017-07-01 }}{{Dead link|date=July 2019 |bot=InternetArchiveBot |fix-attempted=yes}}</ref>
<ref name="Mohnen_2002">{{cite book |author-last=Mohnen |author-first=Markus |title=Compiler Construction |chapter=A Graph—Free Approach to Data—Flow Analysis |date=2002 |volume=2304 |pages=185&ndash;213 |doi=10.1007/3-540-45937-5_6 |series=Lecture Notes in Computer Science |isbn=978-3-540-43369-9 }}</ref>
<ref name="Kuang_2015">{{cite journal |author-last1=Kuang |author-first1=Hongyu |author-last2=Mäder |author-first2=Patrick |author-last3=Hu |author-first3=Hao |author-last4=Ghabi |author-first4=Achraf |author-last5=Huang |author-first5=LiGuo |author-last6=Lü |author-first6=Jian |author-last7=Egyed |author-first7=Alexander |date=2015-11-01 |title=Can method data dependencies support the assessment of traceability between requirements and source code? |journal=Journal of Software: Evolution and Process |volume=27 |issue=11 |pages=838–866 |doi=10.1002/smr.1736 |s2cid=39846438 |issn=2047-7481}}</ref>
<ref name="Naeem_2010">{{Citation |author-last1=Naeem |author-first1=Nomair A. |chapter=Practical Extensions to the IFDS Algorithm |date=2010 |pages=124–144 |publisher=[[Springer Verlag]] |location=Berlin / Heidelberg, Germany |isbn=978-3-64211969-9 |author-last2=Lhoták |author-first2=Ondřej |author-last3=Rodriguez |author-first3=Jonathan |title=Compiler Construction |series=Lecture Notes in Computer Science |volume=6011 |doi=10.1007/978-3-642-11970-5_8|doi-access=free }}</ref>
<ref name="Bodden_2012">{{Cite book |author-last=Bodden |author-first=Eric |title=Proceedings of the ACM SIGPLAN International Workshop on State of the Art in Java Program analysis |chapter=Inter-procedural data-flow analysis with IFDS/IDE and Soot |date=2012 |pages=3–8 |location=New York, New York, USA |publisher=[[ACM Press]] |doi=10.1145/2259051.2259052 |isbn=978-1-45031490-9|s2cid=3020481 }}</ref>
<ref name="Rapoport_2015">{{cite conference |author-last1=Rapoport |author-first1=Marianna | title=Precise Data Flow Analysis in the Presence of Correlated Method Calls |year=2015 | conference = International Static Analysis Symposium |pages=54–71 |publisher=[[Springer Verlag]] |location=Berlin / Heidelberg, Germany |isbn=978-3-66248287-2 |author-last2=Lhoták |author-first2=Ondřej |author-last3=Tip |author-first3=Frank |series=Lecture Notes in Computer Science |volume=9291 |doi=10.1007/978-3-662-48288-9_4}}</ref>
<ref name="Knoop_1996">{{cite journal |author-last1=Knoop |author-first1=Jens |author-last2=Steffen |author-first2=Bernhard |author-link2=Bernhard Steffen (computer scientist) |author-last3=Vollmer |author-first3=Jürgen |date=1996-05-01 |title=Parallelism for free: efficient and optimal bitvector analyses for parallel programs |journal=ACM Transactions on Programming Languages and Systems |volume=18 |issue=3 |pages=268–299 |doi=10.1145/229542.229545 |s2cid=14123780 |issn=0164-0925 |url=https://publikationen.bibliothek.kit.edu/369596|doi-access=free }}</ref>
<ref name="Reps_1995">{{cite book |author-last1=Reps |author-first1=Thomas |author-last2=Horwitz |author-first2=Susan |author-last3=Sagiv |author-first3=Mooly |title=Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '95 |chapter=Precise interprocedural dataflow analysis via graph reachability |date=1995 |pages=1, 49–61 |location=New York, New York, USA |publisher=[[ACM Press]] |doi=10.1145/199448.199462 |isbn=0-89791692-1|s2cid=5955667 }}</ref>
}}

== Further reading ==
* {{cite book |author-first1=Keith D. |author-last1=Cooper |author-link1=Keith D. Cooper |author-first2=Linda |author-last2=Torczon |title=Engineering a Compiler |publisher=[[Morgan Kaufmann]] |date=2003 |orig-year=2002-01-01 |isbn=978-1-55860-698-2}}
* {{cite book |author-first=Steven Stanley |author-last=Muchnick |author-link=Steven Stanley Muchnick |title=Advanced Compiler Design and Implementation |publisher=[[Morgan Kaufmann Publishers]] |date=1997 |isbn=978-1-55860-320-2 |url-access=registration |url=https://archive.org/details/advancedcompiler00much}}
* {{cite book |author-last=Hecht |author-first=Matthew S. |title=Flow Analysis of Computer Programs |publisher=[[Elsevier North-Holland Inc.]] |date=1977-05-03 |series=Programming Languages Series |volume=5 |isbn=978-0-44400210-5 |url-access=registration |url=https://archive.org/details/flowanalysisofco0000hech}}
* {{cite book |url=http://www.cse.iitb.ac.in/~uday/dfaBook-web |author-last1=Khedker |author-first1=Uday P. |author-last2=Sanyal |author-first2=Amitabha |author-last3=Karkare |author-first3=Bageshri |title=Data Flow Analysis: Theory and Practice |publisher=[[CRC Press]] ([[Taylor and Francis Group]]) |date=2009}}
* {{cite book |author-first1=Flemming |author-last1=Nielson |author-first2=Hanne Riis |author-last2=Nielson|author2-link=Hanne Riis Nielson |author-first3=Chris |author-last3=Hankin |title=Principles of Program Analysis |publisher=[[Springer Science+Business Media]] |date=2005}}

{{Compiler optimizations}}

[[Category:Data-flow analysis| ]]
[[Category:Compiler optimizations]]