Control-flow graph
Graphical representation of a computer program or algorithm
- 23 min read
- 11 chapters
Related on Lably
Through Computer science, Directed graph and Function (computer programming)
The CFG is essential to many compiler optimizations and static-analysis tools.
Definition
A control flow graph is the directed graph of the basic blocks of the function (the nodes of the graph) and the control flow between them (the edges of the graph).
The exact details vary between representations. Typically, a basic block consists of a straight-line sequence of instructions or statements. Only the last instruction or statement in each block can perform control flow, and control flow can only be directed to the first instruction or statement in a block.
In most CFG representations, there are two specially designated blocks: the entry block, through which control enters into the function, and the exit block, through which all control exits the function (typically by returning). Some representations permit multiple exit blocks, especially if there are different kinds of exit, or permit the exit block to be omitted if it is not reachable .
If there is a control-flow edge from block A to block B, then A is called a predecessor of B, and B is called a successor of A.
Sign in to keep reading
10 more chapters are free with a Lably account.
Examples
As a simple example, consider the following C function definition:
<span id="mwTQ"></span><span class="kt" id="mwTg">void</span><span class="w" id="mwTw"> </span><span class="nf" id="mwUA">print_within_parentheses</span><span class="p" id="mwUQ">(</span><span class="k" id="mwUg">const</span><span class="w" id="mwUw"> </span><span class="kt" id="mwVA">char</span><span class="w" id="mwVQ"> </span><span class="o" id="mwVg">*</span><span class="n" id="mwVw">p</span><span class="p" id="mwWA">)</span><span class="w" id="mwWQ"> </span><span class="p" id="mwWg">{</span> <span class="w" id="mwWw"> </span><span class="n" id="mwXA">printf</span><span class="p" id="mwXQ">(</span><span class="s" id="mwXg">"("</span><span class="p" id="mwXw">);</span><span class="w" id="mwYA"> </span><span class="c1" id="mwYQ">// 1</span> <span class="w" id="mwYg"> </span><span class="k" id="mwYw">if</span><span class="w" id="mwZA"> </span><span class="p" id="mwZQ">(</span><span class="n" id="mwZg">p</span><span class="w" id="mwZw"> </span><span class="o" id="mwaA">!=</span><span class="w" id="mwaQ"> </span><span class="nb" id="mwag">NULL</span><span class="p" id="mwaw">)</span><span class="w" id="mwbA"> </span><span class="p" id="mwbQ">{</span><span class="w" id="mwbg"> </span><span class="c1" id="mwbw">// 1</span> <span class="w" id="mwcA"> </span><span class="n" id="mwcQ">printf</span><span class="p" id="mwcg">(</span><span class="s" id="mwcw">"%s"</span><span class="p" id="mwdA">,</span><span class="w" id="mwdQ"> </span><span class="n" id="mwdg">p</span><span class="p" id="mwdw">);</span><span class="w" id="mweA"> </span><span class="c1" id="mweQ">// 2</span> <span class="w" id="mweg"> </span><span class="p" id="mwew">}</span><span class="w" id="mwfA"> </span><span class="c1" id="mwfQ">// 2</span> <span class="w" id="mwfg"> </span><span class="n" id="mwfw">printf</span><span class="p" id="mwgA">(</span><span class="s" id="mwgQ">")"</span><span class="p" id="mwgg">);</span><span class="w" id="mwgw"> </span><span class="c1" id="mwhA">// 3</span> <span class="p" id="mwhQ">}</span>This function has three basic blocks:
- Block 1 is the entry block. It runs from the start of the function until the end of the expression
p != NULL. It ends with theifcontrol flow, either entering block 2 if the condition is true or skipping ahead to block 3 if the condition is false. - Block 2 is the body of the
ifstatement. It ends by unconditionally falling into block 3. - Block 3 is the exit block. It runs from the end of the
ifstatement to the implicitreturnat the end of the function body.
The nested structure of the source program makes it a little hard to see the basic blocks. As an alternative representation that makes the blocks more obvious, we can flatten that structure into a sequence of labeled blocks. To make the control flow explicit, we will require each block to end in either goto, an if/else of gotos, or return (only in the exit block).
<span id="mwmQ"></span><span class="kt" id="mwmg">void</span><span class="w" id="mwmw"> </span><span class="nf" id="mwnA">print_within_parentheses</span><span class="p" id="mwnQ">(</span><span class="k" id="mwng">const</span><span class="w" id="mwnw"> </span><span class="kt" id="mwoA">char</span><span class="w" id="mwoQ"> </span><span class="o" id="mwog">*</span><span class="n" id="mwow">p</span><span class="p" id="mwpA">)</span><span class="w" id="mwpQ"> </span><span class="p" id="mwpg">{</span> <span class="w" id="mwpw"> </span><span class="nl" id="mwqA">block1</span><span class="p" id="mwqQ">:</span><span class="w" id="mwqg"> </span><span class="p" id="mwqw">{</span> <span class="w" id="mwrA"> </span><span class="n" id="mwrQ">printf</span><span class="p" id="mwrg">(</span><span class="s" id="mwrw">"("</span><span class="p" id="mwsA">);</span> <span class="w" id="mwsQ"> </span><span class="k" id="mwsg">if</span><span class="w" id="mwsw"> </span><span class="p" id="mwtA">(</span><span class="n" id="mwtQ">p</span><span class="w" id="mwtg"> </span><span class="o" id="mwtw">!=</span><span class="w" id="mwuA"> </span><span class="nb" id="mwuQ">NULL</span><span class="p" id="mwug">)</span><span class="w" id="mwuw"> </span><span class="p" id="mwvA">{</span><span class="w" id="mwvQ"> </span><span class="k" id="mwvg">goto</span><span class="w" id="mwvw"> </span><span class="n" id="mwwA">block2</span><span class="p" id="mwwQ">;</span><span class="w" id="mwwg"> </span><span class="p" id="mwww">}</span><span class="w" id="mwxA"> </span><span class="k" id="mwxQ">else</span><span class="w" id="mwxg"> </span><span class="p" id="mwxw">{</span><span class="w" id="mwyA"> </span><span class="k" id="mwyQ">goto</span><span class="w" id="mwyg"> </span><span class="n" id="mwyw">block3</span><span class="p" id="mwzA">;</span><span class="w" id="mwzQ"> </span><span class="p" id="mwzg">}</span> <span class="w" id="mwzw"> </span><span class="p" id="mw0A">}</span> <span class="w" id="mw0Q"> </span><span class="nl" id="mw0g">block2</span><span class="p" id="mw0w">:</span><span class="w" id="mw1A"> </span><span class="p" id="mw1Q">{</span> <span class="w" id="mw1g"> </span><span class="n" id="mw1w">printf</span><span class="p" id="mw2A">(</span><span class="s" id="mw2Q">"%s"</span><span class="p" id="mw2g">,</span><span class="w" id="mw2w"> </span><span class="n" id="mw3A">p</span><span class="p" id="mw3Q">);</span> <span class="w" id="mw3g"> </span><span class="k" id="mw3w">goto</span><span class="w" id="mw4A"> </span><span class="n" id="mw4Q">block3</span><span class="p" id="mw4g">;</span> <span class="w" id="mw4w"> </span><span class="p" id="mw5A">}</span> <span class="w" id="mw5Q"> </span><span class="nl" id="mw5g">block3</span><span class="p" id="mw5w">:</span><span class="w" id="mw6A"> </span><span class="p" id="mw6Q">{</span> <span class="w" id="mw6g"> </span><span class="n" id="mw6w">printf</span><span class="p" id="mw7A">(</span><span class="s" id="mw7Q">")"</span><span class="p" id="mw7g">);</span> <span class="w" id="mw7w"> </span><span class="k" id="mw8A">return</span><span class="p" id="mw8Q">;</span> <span class="w" id="mw8g"> </span><span class="p" id="mw8w">}</span> <span class="p" id="mw9A">}</span>This is a source-level representation of the CFG. The basic blocks consist of sequences of C statements taken directly from the source program. Only the structured control flow has been eliminated.
Now consider a more complex example which includes a loop:
<span id="mw-Q"></span><span class="kt" id="mw-g">void</span><span class="w" id="mw-w"> </span><span class="nf" id="mw_A">print_as_ordered_tuple</span><span class="p" id="mw_Q">(</span><span class="k" id="mw_g">const</span><span class="w" id="mw_w"> </span><span class="kt" id="mwAQA">char</span><span class="w" id="mwAQE"> </span><span class="o" id="mwAQI">*</span><span class="w" id="mwAQM"> </span><span class="k" id="mwAQQ">const</span><span class="w" id="mwAQU"> </span><span class="o" id="mwAQY">*</span><span class="n" id="mwAQc">p</span><span class="p" id="mwAQg">)</span><span class="w" id="mwAQk"> </span><span class="p" id="mwAQo">{</span> <span class="w" id="mwAQs"> </span><span class="n" id="mwAQw">printf</span><span class="p" id="mwAQ0">(</span><span class="s" id="mwAQ4">"("</span><span class="p" id="mwAQ8">);</span><span class="w" id="mwARA"> </span><span class="c1" id="mwARE">// 1</span> <span class="w" id="mwARI"> </span><span class="kt" id="mwARM">bool</span><span class="w" id="mwARQ"> </span><span class="n" id="mwARU">first</span><span class="w" id="mwARY"> </span><span class="o" id="mwARc">=</span><span class="w" id="mwARg"> </span><span class="nb" id="mwARk">true</span><span class="p" id="mwARo">;</span><span class="w" id="mwARs"> </span><span class="c1" id="mwARw">// 1</span> <span class="w" id="mwAR0"> </span><span class="k" id="mwAR4">for</span><span class="w" id="mwAR8"> </span><span class="p" id="mwASA">(;</span><span class="w" id="mwASE"> </span><span class="o" id="mwASI">*</span><span class="n" id="mwASM">p</span><span class="w" id="mwASQ"> </span><span class="o" id="mwASU">!=</span><span class="w" id="mwASY"> </span><span class="nb" id="mwASc">NULL</span><span class="p" id="mwASg">;</span><span class="w" id="mwASk"> </span><span class="o" id="mwASo">++</span><span class="n" id="mwASs">p</span><span class="p" id="mwASw">)</span><span class="w" id="mwAS0"> </span><span class="p" id="mwAS4">{</span><span class="w" id="mwAS8"> </span><span class="c1" id="mwATA">// 2</span> <span class="w" id="mwATE"> </span><span class="k" id="mwATI">if</span><span class="w" id="mwATM"> </span><span class="p" id="mwATQ">(</span><span class="o" id="mwATU">!</span><span class="n" id="mwATY">first</span><span class="p" id="mwATc">)</span><span class="w" id="mwATg"> </span><span class="p" id="mwATk">{</span><span class="w" id="mwATo"> </span><span class="c1" id="mwATs">// 3</span> <span class="w" id="mwATw"> </span><span class="n" id="mwAT0">printf</span><span class="p" id="mwAT4">(</span><span class="s" id="mwAT8">","</span><span class="p" id="mwAUA">);</span><span class="w" id="mwAUE"> </span><span class="c1" id="mwAUI">// 4</span> <span class="w" id="mwAUM"> </span><span class="p" id="mwAUQ">}</span><span class="w" id="mwAUU"> </span><span class="c1" id="mwAUY">// 4</span> <span class="w" id="mwAUc"> </span><span class="n" id="mwAUg">first</span><span class="w" id="mwAUk"> </span><span class="o" id="mwAUo">=</span><span class="w" id="mwAUs"> </span><span class="nb" id="mwAUw">false</span><span class="p" id="mwAU0">;</span><span class="w" id="mwAU4"> </span><span class="c1" id="mwAU8">// 5</span> <span class="w" id="mwAVA"> </span><span class="n" id="mwAVE">printf</span><span class="p" id="mwAVI">(</span><span class="s" id="mwAVM">"%s"</span><span class="p" id="mwAVQ">,</span><span class="w" id="mwAVU"> </span><span class="o" id="mwAVY">*</span><span class="n" id="mwAVc">p</span><span class="p" id="mwAVg">);</span><span class="w" id="mwAVk"> </span><span class="c1" id="mwAVo">// 5</span> <span class="w" id="mwAVs"> </span><span class="p" id="mwAVw">}</span><span class="w" id="mwAV0"> </span><span class="c1" id="mwAV4">// 5</span> <span class="w" id="mwAV8"> </span><span class="n" id="mwAWA">printf</span><span class="p" id="mwAWE">(</span><span class="s" id="mwAWI">")"</span><span class="p" id="mwAWM">);</span><span class="w" id="mwAWQ"> </span><span class="c1" id="mwAWU">// 6</span> <span class="p" id="mwAWY">}</span>This function has six basic blocks, which can be clearly seen in our source-level representation of the CFG:
<span id="mwAWo"></span><span class="kt" id="mwAWs">void</span><span class="w" id="mwAWw"> </span><span class="nf" id="mwAW0">print_as_ordered_tuple</span><span class="p" id="mwAW4">(</span><span class="k" id="mwAW8">const</span><span class="w" id="mwAXA"> </span><span class="kt" id="mwAXE">char</span><span class="w" id="mwAXI"> </span><span class="o" id="mwAXM">*</span><span class="n" id="mwAXQ">p</span><span class="p" id="mwAXU">)</span><span class="w" id="mwAXY"> </span><span class="p" id="mwAXc">{</span> <span class="w" id="mwAXg"> </span><span class="kt" id="mwAXk">bool</span><span class="w" id="mwAXo"> </span><span class="n" id="mwAXs">first</span><span class="p" id="mwAXw">;</span> <span class="w" id="mwAX0"> </span><span class="nl" id="mwAX4">block1</span><span class="p" id="mwAX8">:</span><span class="w" id="mwAYA"> </span><span class="p" id="mwAYE">{</span> <span class="w" id="mwAYI"> </span><span class="n" id="mwAYM">printf</span><span class="p" id="mwAYQ">(</span><span class="s" id="mwAYU">"("</span><span class="p" id="mwAYY">);</span> <span class="w" id="mwAYc"> </span><span class="n" id="mwAYg">first</span><span class="w" id="mwAYk"> </span><span class="o" id="mwAYo">=</span><span class="w" id="mwAYs"> </span><span class="nb" id="mwAYw">true</span><span class="p" id="mwAY0">;</span> <span class="w" id="mwAY4"> </span><span class="k" id="mwAY8">goto</span><span class="w" id="mwAZA"> </span><span class="n" id="mwAZE">block2</span><span class="p" id="mwAZI">;</span> <span class="w" id="mwAZM"> </span><span class="p" id="mwAZQ">}</span> <span class="w" id="mwAZU"> </span><span class="nl" id="mwAZY">block2</span><span class="p" id="mwAZc">:</span><span class="w" id="mwAZg"> </span><span class="p" id="mwAZk">{</span> <span class="w" id="mwAZo"> </span><span class="k" id="mwAZs">if</span><span class="w" id="mwAZw"> </span><span class="p" id="mwAZ0">(</span><span class="o" id="mwAZ4">*</span><span class="n" id="mwAZ8">p</span><span class="w" id="mwAaA"> </span><span class="o" id="mwAaE">!=</span><span class="w" id="mwAaI"> </span><span class="nb" id="mwAaM">NULL</span><span class="p" id="mwAaQ">)</span><span class="w" id="mwAaU"> </span><span class="p" id="mwAaY">{</span><span class="w" id="mwAac"> </span><span class="k" id="mwAag">goto</span><span class="w" id="mwAak"> </span><span class="n" id="mwAao">block3</span><span class="p" id="mwAas">;</span><span class="w" id="mwAaw"> </span><span class="p" id="mwAa0">}</span><span class="w" id="mwAa4"> </span><span class="k" id="mwAa8">else</span><span class="w" id="mwAbA"> </span><span class="p" id="mwAbE">{</span><span class="w" id="mwAbI"> </span><span class="k" id="mwAbM">goto</span><span class="w" id="mwAbQ"> </span><span class="n" id="mwAbU">block6</span><span class="p" id="mwAbY">;</span><span class="w" id="mwAbc"> </span><span class="p" id="mwAbg">}</span> <span class="w" id="mwAbk"> </span><span class="p" id="mwAbo">}</span> <span class="w" id="mwAbs"> </span><span class="nl" id="mwAbw">block3</span><span class="p" id="mwAb0">:</span><span class="w" id="mwAb4"> </span><span class="p" id="mwAb8">{</span> <span class="w" id="mwAcA"> </span><span class="k" id="mwAcE">if</span><span class="w" id="mwAcI"> </span><span class="p" id="mwAcM">(</span><span class="o" id="mwAcQ">!</span><span class="n" id="mwAcU">first</span><span class="p" id="mwAcY">)</span><span class="w" id="mwAcc"> </span><span class="p" id="mwAcg">{</span><span class="w" id="mwAck"> </span><span class="k" id="mwAco">goto</span><span class="w" id="mwAcs"> </span><span class="n" id="mwAcw">block4</span><span class="p" id="mwAc0">;</span><span class="w" id="mwAc4"> </span><span class="p" id="mwAc8">}</span><span class="w" id="mwAdA"> </span><span class="k" id="mwAdE">else</span><span class="w" id="mwAdI"> </span><span class="p" id="mwAdM">{</span><span class="w" id="mwAdQ"> </span><span class="k" id="mwAdU">goto</span><span class="w" id="mwAdY"> </span><span class="n" id="mwAdc">block5</span><span class="p" id="mwAdg">;</span><span class="w" id="mwAdk"> </span><span class="p" id="mwAdo">}</span> <span class="w" id="mwAds"> </span><span class="p" id="mwAdw">}</span> <span class="w" id="mwAd0"> </span><span class="nl" id="mwAd4">block4</span><span class="p" id="mwAd8">:</span><span class="w" id="mwAeA"> </span><span class="p" id="mwAeE">{</span> <span class="w" id="mwAeI"> </span><span class="n" id="mwAeM">printf</span><span class="p" id="mwAeQ">(</span><span class="s" id="mwAeU">","</span><span class="p" id="mwAeY">);</span> <span class="w" id="mwAec"> </span><span class="k" id="mwAeg">goto</span><span class="w" id="mwAek"> </span><span class="n" id="mwAeo">block5</span><span class="p" id="mwAes">;</span> <span class="w" id="mwAew"> </span><span class="p" id="mwAe0">}</span> <span class="w" id="mwAe4"> </span><span class="nl" id="mwAe8">block5</span><span class="p" id="mwAfA">:</span><span class="w" id="mwAfE"> </span><span class="p" id="mwAfI">{</span> <span class="w" id="mwAfM"> </span><span class="n" id="mwAfQ">first</span><span class="w" id="mwAfU"> </span><span class="o" id="mwAfY">=</span><span class="w" id="mwAfc"> </span><span class="nb" id="mwAfg">false</span><span class="p" id="mwAfk">;</span> <span class="w" id="mwAfo"> </span><span class="n" id="mwAfs">printf</span><span class="p" id="mwAfw">(</span><span class="s" id="mwAf0">"%s"</span><span class="p" id="mwAf4">,</span><span class="w" id="mwAf8"> </span><span class="o" id="mwAgA">*</span><span class="n" id="mwAgE">p</span><span class="p" id="mwAgI">);</span> <span class="w" id="mwAgM"> </span><span class="o" id="mwAgQ">++</span><span class="n" id="mwAgU">p</span><span class="p" id="mwAgY">;</span> <span class="w" id="mwAgc"> </span><span class="k" id="mwAgg">goto</span><span class="w" id="mwAgk"> </span><span class="n" id="mwAgo">block2</span><span class="p" id="mwAgs">;</span> <span class="w" id="mwAgw"> </span><span class="p" id="mwAg0">}</span> <span class="w" id="mwAg4"> </span><span class="nl" id="mwAg8">block6</span><span class="p" id="mwAhA">:</span><span class="w" id="mwAhE"> </span><span class="p" id="mwAhI">{</span> <span class="w" id="mwAhM"> </span><span class="n" id="mwAhQ">printf</span><span class="p" id="mwAhU">(</span><span class="s" id="mwAhY">")"</span><span class="p" id="mwAhc">);</span> <span class="w" id="mwAhg"> </span><span class="k" id="mwAhk">return</span><span class="p" id="mwAho">;</span> <span class="w" id="mwAhs"> </span><span class="p" id="mwAhw">}</span> <span class="p" id="mwAh0">}</span>This style of statement-level CFG representation is not commonly used, and it is shown here only for illustrative purposes. Not all programs can be easily represented this way, even in C. Notice how the local variable declaration has been raised to the top of function, and its initialization in block1 has been turned into an assignment. This would cause difficulties for scope-driven features such as shadowing and variable-length arrays. Statements would also need to be significantly rewritten to deal with expression-level control flow, such as is introduced by the &&, ||, and ? : operators.
Most practical CFG representations use something other than complete source statements as the components of their basic blocks. For example, compiler frameworks such as LLVM use a CFG in which basic blocks consist of abstract static single-assignment instructions as their primary IR. Here is the above function translated into LLVM IR:
<span id="mwAio"></span><span class="k" id="mwAis">define</span><span class="w" id="mwAiw"> </span><span class="k" id="mwAi0">void</span><span class="w" id="mwAi4"> </span><span class="vg" id="mwAi8">@print_as_ordered_tuple</span><span class="p" id="mwAjA">(</span><span class="kt" id="mwAjE">ptr</span><span class="w" id="mwAjI"> </span><span class="nv nv-Anonymous" id="mwAjM">%0</span><span class="p" id="mwAjQ">)</span><span class="w" id="mwAjU"> </span><span class="p" id="mwAjY">{</span> <span class="nl" id="mwAjc">block1:</span> <span class="w" id="mwAjg"> </span><span class="nv" id="mwAjk">%p</span><span class="w" id="mwAjo"> </span><span class="p" id="mwAjs">=</span><span class="w" id="mwAjw"> </span><span class="k" id="mwAj0">alloca</span><span class="w" id="mwAj4"> </span><span class="kt" id="mwAj8">ptr</span> <span class="w" id="mwAkA"> </span><span class="nv" id="mwAkE">%first</span><span class="w" id="mwAkI"> </span><span class="p" id="mwAkM">=</span><span class="w" id="mwAkQ"> </span><span class="k" id="mwAkU">alloca</span><span class="w" id="mwAkY"> </span><span class="kt" id="mwAkc">i1</span> <span class="w" id="mwAkg"> </span><span class="k" id="mwAkk">store</span><span class="w" id="mwAko"> </span><span class="kt" id="mwAks">ptr</span><span class="w" id="mwAkw"> </span><span class="nv nv-Anonymous" id="mwAk0">%0</span><span class="p" id="mwAk4">,</span><span class="w" id="mwAk8"> </span><span class="kt" id="mwAlA">ptr</span><span class="w" id="mwAlE"> </span><span class="nv" id="mwAlI">%p</span> <span class="w" id="mwAlM"> </span><span class="k" id="mwAlQ">call</span><span class="w" id="mwAlU"> </span><span class="kt" id="mwAlY">i32</span><span class="w" id="mwAlc"> </span><span class="p" id="mwAlg">(</span><span class="kt" id="mwAlk">ptr</span><span class="p" id="mwAlo">,</span><span class="w" id="mwAls"> </span><span class="p" id="mwAlw">...)</span><span class="w" id="mwAl0"> </span><span class="vg" id="mwAl4">@printf</span><span class="p" id="mwAl8">(</span><span class="kt" id="mwAmA">ptr</span><span class="w" id="mwAmE"> </span><span class="vg" id="mwAmI">@"("</span><span class="p" id="mwAmM">)</span> <span class="w" id="mwAmQ"> </span><span class="k" id="mwAmU">store</span><span class="w" id="mwAmY"> </span><span class="kt" id="mwAmc">i1</span><span class="w" id="mwAmg"> </span><span class="m" id="mwAmk">1</span><span class="p" id="mwAmo">,</span><span class="w" id="mwAms"> </span><span class="kt" id="mwAmw">ptr</span><span class="w" id="mwAm0"> </span><span class="nv" id="mwAm4">%first</span> <span class="w" id="mwAm8"> </span><span class="k" id="mwAnA">br</span><span class="w" id="mwAnE"> </span><span class="kt" id="mwAnI">label</span><span class="w" id="mwAnM"> </span><span class="nv" id="mwAnQ">%block2</span> <span class="nl" id="mwAnU">block2:</span> <span class="w" id="mwAnY"> </span><span class="nv nv-Anonymous" id="mwAnc">%1</span><span class="w" id="mwAng"> </span><span class="p" id="mwAnk">=</span><span class="w" id="mwAno"> </span><span class="k" id="mwAns">load</span><span class="w" id="mwAnw"> </span><span class="kt" id="mwAn0">ptr</span><span class="p" id="mwAn4">,</span><span class="w" id="mwAn8"> </span><span class="kt" id="mwAoA">ptr</span><span class="w" id="mwAoE"> </span><span class="nv" id="mwAoI">%p</span> <span class="w" id="mwAoM"> </span><span class="nv nv-Anonymous" id="mwAoQ">%2</span><span class="w" id="mwAoU"> </span><span class="p" id="mwAoY">=</span><span class="w" id="mwAoc"> </span><span class="k" id="mwAog">load</span><span class="w" id="mwAok"> </span><span class="kt" id="mwAoo">ptr</span><span class="p" id="mwAos">,</span><span class="w" id="mwAow"> </span><span class="kt" id="mwAo0">ptr</span><span class="w" id="mwAo4"> </span><span class="nv nv-Anonymous" id="mwAo8">%1</span> <span class="w" id="mwApA"> </span><span class="nv nv-Anonymous" id="mwApE">%3</span><span class="w" id="mwApI"> </span><span class="p" id="mwApM">=</span><span class="w" id="mwApQ"> </span><span class="k" id="mwApU">icmp</span><span class="w" id="mwApY"> </span><span class="k" id="mwApc">ne</span><span class="w" id="mwApg"> </span><span class="kt" id="mwApk">ptr</span><span class="w" id="mwApo"> </span><span class="nv nv-Anonymous" id="mwAps">%2</span><span class="p" id="mwApw">,</span><span class="w" id="mwAp0"> </span><span class="k" id="mwAp4">null</span> <span class="w" id="mwAp8"> </span><span class="k" id="mwAqA">br</span><span class="w" id="mwAqE"> </span><span class="kt" id="mwAqI">i1</span><span class="w" id="mwAqM"> </span><span class="nv nv-Anonymous" id="mwAqQ">%1</span><span class="p" id="mwAqU">,</span><span class="w" id="mwAqY"> </span><span class="kt" id="mwAqc">label</span><span class="w" id="mwAqg"> </span><span class="nv" id="mwAqk">%block3</span><span class="p" id="mwAqo">,</span><span class="w" id="mwAqs"> </span><span class="kt" id="mwAqw">label</span><span class="w" id="mwAq0"> </span><span class="nv" id="mwAq4">%block4</span> <span class="nl" id="mwAq8">block3:</span> <span class="w" id="mwArA"> </span><span class="nv nv-Anonymous" id="mwArE">%4</span><span class="w" id="mwArI"> </span><span class="p" id="mwArM">=</span><span class="w" id="mwArQ"> </span><span class="k" id="mwArU">load</span><span class="w" id="mwArY"> </span><span class="kt" id="mwArc">i1</span><span class="p" id="mwArg">,</span><span class="w" id="mwArk"> </span><span class="kt" id="mwAro">ptr</span><span class="w" id="mwArs"> </span><span class="nv" id="mwArw">%first</span> <span class="w" id="mwAr0"> </span><span class="k" id="mwAr4">br</span><span class="w" id="mwAr8"> </span><span class="kt" id="mwAsA">i1</span><span class="w" id="mwAsE"> </span><span class="nv nv-Anonymous" id="mwAsI">%4</span><span class="p" id="mwAsM">,</span><span class="w" id="mwAsQ"> </span><span class="kt" id="mwAsU">label</span><span class="w" id="mwAsY"> </span><span class="nv" id="mwAsc">%block4</span><span class="p" id="mwAsg">,</span><span class="w" id="mwAsk"> </span><span class="kt" id="mwAso">label</span><span class="w" id="mwAss"> </span><span class="nv" id="mwAsw">%block5</span> <span class="nl" id="mwAs0">block4:</span> <span class="w" id="mwAs4"> </span><span class="k" id="mwAs8">call</span><span class="w" id="mwAtA"> </span><span class="kt" id="mwAtE">i32</span><span class="w" id="mwAtI"> </span><span class="p" id="mwAtM">(</span><span class="kt" id="mwAtQ">ptr</span><span class="p" id="mwAtU">,</span><span class="w" id="mwAtY"> </span><span class="p" id="mwAtc">...)</span><span class="w" id="mwAtg"> </span><span class="vg" id="mwAtk">@printf</span><span class="p" id="mwAto">(</span><span class="kt" id="mwAts">ptr</span><span class="w" id="mwAtw"> </span><span class="vg" id="mwAt0">@","</span><span class="p" id="mwAt4">)</span> <span class="w" id="mwAt8"> </span><span class="k" id="mwAuA">br</span><span class="w" id="mwAuE"> </span><span class="kt" id="mwAuI">label</span><span class="w" id="mwAuM"> </span><span class="nv" id="mwAuQ">%block5</span> <span class="nl" id="mwAuU">block5:</span> <span class="w" id="mwAuY"> </span><span class="k" id="mwAuc">store</span><span class="w" id="mwAug"> </span><span class="kt" id="mwAuk">i1</span><span class="w" id="mwAuo"> </span><span class="m" id="mwAus">0</span><span class="p" id="mwAuw">,</span><span class="w" id="mwAu0"> </span><span class="kt" id="mwAu4">ptr</span><span class="w" id="mwAu8"> </span><span class="nv" id="mwAvA">%first</span> <span class="w" id="mwAvE"> </span><span class="nv nv-Anonymous" id="mwAvI">%5</span><span class="w" id="mwAvM"> </span><span class="p" id="mwAvQ">=</span><span class="w" id="mwAvU"> </span><span class="k" id="mwAvY">load</span><span class="w" id="mwAvc"> </span><span class="kt" id="mwAvg">ptr</span><span class="p" id="mwAvk">,</span><span class="w" id="mwAvo"> </span><span class="kt" id="mwAvs">ptr</span><span class="w" id="mwAvw"> </span><span class="nv" id="mwAv0">%p</span> <span class="w" id="mwAv4"> </span><span class="nv nv-Anonymous" id="mwAv8">%6</span><span class="w" id="mwAwA"> </span><span class="p" id="mwAwE">=</span><span class="w" id="mwAwI"> </span><span class="k" id="mwAwM">load</span><span class="w" id="mwAwQ"> </span><span class="kt" id="mwAwU">ptr</span><span class="p" id="mwAwY">,</span><span class="w" id="mwAwc"> </span><span class="kt" id="mwAwg">ptr</span><span class="w" id="mwAwk"> </span><span class="nv nv-Anonymous" id="mwAwo">%5</span> <span class="w" id="mwAws"> </span><span class="k" id="mwAww">call</span><span class="w" id="mwAw0"> </span><span class="kt" id="mwAw4">i32</span><span class="w" id="mwAw8"> </span><span class="p" id="mwAxA">(</span><span class="kt" id="mwAxE">ptr</span><span class="p" id="mwAxI">,</span><span class="w" id="mwAxM"> </span><span class="p" id="mwAxQ">...)</span><span class="w" id="mwAxU"> </span><span class="vg" id="mwAxY">@printf</span><span class="p" id="mwAxc">(</span><span class="kt" id="mwAxg">ptr</span><span class="w" id="mwAxk"> </span><span class="vg" id="mwAxo">@"%s"</span><span class="p" id="mwAxs">,</span><span class="w" id="mwAxw"> </span><span class="kt" id="mwAx0">ptr</span><span class="w" id="mwAx4"> </span><span class="nv nv-Anonymous" id="mwAx8">%6</span><span class="p" id="mwAyA">)</span> <span class="w" id="mwAyE"> </span><span class="nv nv-Anonymous" id="mwAyI">%7</span><span class="w" id="mwAyM"> </span><span class="p" id="mwAyQ">=</span><span class="w" id="mwAyU"> </span><span class="k" id="mwAyY">load</span><span class="w" id="mwAyc"> </span><span class="kt" id="mwAyg">ptr</span><span class="p" id="mwAyk">,</span><span class="w" id="mwAyo"> </span><span class="kt" id="mwAys">ptr</span><span class="w" id="mwAyw"> </span><span class="nv" id="mwAy0">%p</span> <span class="w" id="mwAy4"> </span><span class="nv nv-Anonymous" id="mwAy8">%8</span><span class="w" id="mwAzA"> </span><span class="p" id="mwAzE">=</span><span class="w" id="mwAzI"> </span><span class="k" id="mwAzM">getelementptr</span><span class="w" id="mwAzQ"> </span><span class="k" id="mwAzU">inbounds</span><span class="w" id="mwAzY"> </span><span class="kt" id="mwAzc">ptr</span><span class="p" id="mwAzg">,</span><span class="w" id="mwAzk"> </span><span class="kt" id="mwAzo">ptr</span><span class="w" id="mwAzs"> </span><span class="nv nv-Anonymous" id="mwAzw">%7</span><span class="p" id="mwAz0">,</span><span class="w" id="mwAz4"> </span><span class="kt" id="mwAz8">i32</span><span class="w" id="mwA0A"> </span><span class="m" id="mwA0E">1</span> <span class="w" id="mwA0I"> </span><span class="k" id="mwA0M">store</span><span class="w" id="mwA0Q"> </span><span class="kt" id="mwA0U">ptr</span><span class="w" id="mwA0Y"> </span><span class="nv nv-Anonymous" id="mwA0c">%8</span><span class="p" id="mwA0g">,</span><span class="w" id="mwA0k"> </span><span class="kt" id="mwA0o">ptr</span><span class="w" id="mwA0s"> </span><span class="nv" id="mwA0w">%p</span> <span class="w" id="mwA00"> </span><span class="k" id="mwA04">br</span><span class="w" id="mwA08"> </span><span class="kt" id="mwA1A">label</span><span class="w" id="mwA1E"> </span><span class="nv" id="mwA1I">%block2</span> <span class="nl" id="mwA1M">block6:</span> <span class="w" id="mwA1Q"> </span><span class="k" id="mwA1U">call</span><span class="w" id="mwA1Y"> </span><span class="kt" id="mwA1c">i32</span><span class="w" id="mwA1g"> </span><span class="p" id="mwA1k">(</span><span class="kt" id="mwA1o">ptr</span><span class="p" id="mwA1s">,</span><span class="w" id="mwA1w"> </span><span class="p" id="mwA10">...)</span><span class="w" id="mwA14"> </span><span class="vg" id="mwA18">@printf</span><span class="p" id="mwA2A">(</span><span class="kt" id="mwA2E">ptr</span><span class="w" id="mwA2I"> </span><span class="vg" id="mwA2M">@")"</span><span class="p" id="mwA2Q">)</span> <span class="w" id="mwA2U"> </span><span class="k" id="mwA2Y">ret</span><span class="w" id="mwA2c"> </span><span class="k" id="mwA2g">void</span> <span class="p" id="mwA2k">}</span>Notice how the block structure is the same in the source-level and the LLVM CFGs. In both representations, the functions have the same basic semantics, performing the same sequence of operations and control flow. Only the representation of the individual operations is different.
Construction
A very explicit control flow graph can be obtained from a source function by placing each statement into its own basic block. If the statement is not a control-flow statement, a "fall-through" jump to the block for the next statement is added to the block. Unfortunately, this tends to create a large number of unnecessary basic blocks and fall-through jumps, which makes subsequent analysis more cumbersome and expensive. It is usually desirable that successive statements be placed in the same basic block whenever possible. Another way to say this is that, across the entire CFG, every edge A→B should have the property that:
Such a graph can be derived from the one-statement-per-block CFG by performing an edge contraction for every edge that falsifies the predicate above, which is to say, by merging two blocks whenever the source block always jumps to the destination block and the destination block can only be jumped to by the source block. However, this contraction-based algorithm is of little practical importance except as a visualization aid for understanding CFG construction because of the expense of building the initial form. In typical implementations, the CFG is built directly from the program in a way that minimizes unnecessary blocks by construction, such as by scanning the program for necessary boundaries between basic blocks.
Reachability
Reachability is a graph property useful in optimization. If a block cannot be reached by any path from the entry block, then it cannot possibly be executed, in which case it is called unreachable code. Unreachable code can usually be removed from the control flow graph without any negative consequences.
If the exit block cannot be reached by any path from the entry block, then control flow cannot leave the graph normally. This indicates the presence of either an infinite loop or, in representations that directly support these features, an abnormal exit or termination of the program. The exit block being reachable by some path does not mean that the program will necessarily reach it, and it is impossible to prove that it will be reached in a general graph; see Halting problem.
Optimization can reveal unreachable code and infinite loops that were not apparent in the original program. For example, consider the following LLVM function:
<span id="mwA4k"></span><span class="k" id="mwA4o">define</span><span class="w" id="mwA4s"> </span><span class="k" id="mwA4w">void</span><span class="w" id="mwA40"> </span><span class="vg" id="mwA44">@double_until_odd</span><span class="p" id="mwA48">(</span><span class="kt" id="mwA5A">ptr</span><span class="w" id="mwA5E"> </span><span class="nv" id="mwA5I">%p</span><span class="p" id="mwA5M">)</span><span class="w" id="mwA5Q"> </span><span class="p" id="mwA5U">{</span> <span class="nl" id="mwA5Y">block1:</span> <span class="w" id="mwA5c"> </span><span class="k" id="mwA5g">br</span><span class="w" id="mwA5k"> </span><span class="kt" id="mwA5o">label</span><span class="w" id="mwA5s"> </span><span class="nv" id="mwA5w">%block2</span> <span class="nl" id="mwA50">block2:</span> <span class="w" id="mwA54"> </span><span class="nv nv-Anonymous" id="mwA58">%0</span><span class="w" id="mwA6A"> </span><span class="p" id="mwA6E">=</span><span class="w" id="mwA6I"> </span><span class="k" id="mwA6M">load</span><span class="w" id="mwA6Q"> </span><span class="kt" id="mwA6U">i32</span><span class="p" id="mwA6Y">,</span><span class="w" id="mwA6c"> </span><span class="kt" id="mwA6g">ptr</span><span class="w" id="mwA6k"> </span><span class="nv" id="mwA6o">%p</span><span class="w" id="mwA6s"> </span><span class="c" id="mwA6w">; Load the current value from %p</span> <span class="w" id="mwA60"> </span><span class="nv nv-Anonymous" id="mwA64">%1</span><span class="w" id="mwA68"> </span><span class="p" id="mwA7A">=</span><span class="w" id="mwA7E"> </span><span class="k" id="mwA7I">mul</span><span class="w" id="mwA7M"> </span><span class="kt" id="mwA7Q">i32</span><span class="w" id="mwA7U"> </span><span class="nv nv-Anonymous" id="mwA7Y">%0</span><span class="p" id="mwA7c">,</span><span class="w" id="mwA7g"> </span><span class="m" id="mwA7k">2</span><span class="w" id="mwA7o"> </span><span class="c" id="mwA7s">; Multiply it by 2</span> <span class="w" id="mwA7w"> </span><span class="k" id="mwA70">store</span><span class="w" id="mwA74"> </span><span class="kt" id="mwA78">i32</span><span class="w" id="mwA8A"> </span><span class="nv nv-Anonymous" id="mwA8E">%1</span><span class="p" id="mwA8I">,</span><span class="w" id="mwA8M"> </span><span class="kt" id="mwA8Q">ptr</span><span class="w" id="mwA8U"> </span><span class="nv" id="mwA8Y">%p</span><span class="w" id="mwA8c"> </span><span class="c" id="mwA8g">; Store that back into %p</span> <span class="w" id="mwA8k"> </span><span class="nv nv-Anonymous" id="mwA8o">%2</span><span class="w" id="mwA8s"> </span><span class="p" id="mwA8w">=</span><span class="w" id="mwA80"> </span><span class="k" id="mwA84">and</span><span class="w" id="mwA88"> </span><span class="kt" id="mwA9A">i32</span><span class="w" id="mwA9E"> </span><span class="nv nv-Anonymous" id="mwA9I">%1</span><span class="p" id="mwA9M">,</span><span class="w" id="mwA9Q"> </span><span class="m" id="mwA9U">1</span><span class="w" id="mwA9Y"> </span><span class="c" id="mwA9c">; Mask off the low bit of the product</span> <span class="w" id="mwA9g"> </span><span class="nv nv-Anonymous" id="mwA9k">%3</span><span class="w" id="mwA9o"> </span><span class="p" id="mwA9s">=</span><span class="w" id="mwA9w"> </span><span class="k" id="mwA90">icmp</span><span class="w" id="mwA94"> </span><span class="k" id="mwA98">eq</span><span class="w" id="mwA-A"> </span><span class="kt" id="mwA-E">i32</span><span class="w" id="mwA-I"> </span><span class="nv nv-Anonymous" id="mwA-M">%2</span><span class="p" id="mwA-Q">,</span><span class="w" id="mwA-U"> </span><span class="m" id="mwA-Y">0</span><span class="w" id="mwA-c"> </span><span class="c" id="mwA-g">; Check if that's 0</span> <span class="w" id="mwA-k"> </span><span class="k" id="mwA-o">br</span><span class="w" id="mwA-s"> </span><span class="kt" id="mwA-w">i1</span><span class="w" id="mwA-0"> </span><span class="nv nv-Anonymous" id="mwA-4">%3</span><span class="p" id="mwA-8">,</span><span class="w" id="mwA_A"> </span><span class="kt" id="mwA_E">label</span><span class="w" id="mwA_I"> </span><span class="nv" id="mwA_M">%block2</span><span class="p" id="mwA_Q">,</span><span class="w" id="mwA_U"> </span><span class="kt" id="mwA_Y">label</span><span class="w" id="mwA_c"> </span><span class="nv" id="mwA_g">%block3</span><span class="w" id="mwA_k"> </span><span class="c" id="mwA_o">; Loop if so</span> <span class="nl" id="mwA_s">block3:</span> <span class="w" id="mwA_w"> </span><span class="k" id="mwA_0">ret</span><span class="w" id="mwA_4"> </span><span class="k" id="mwA_8">void</span> <span class="p" id="mwBAA">}</span>In this form, the loop in this function is not an infinite loop because there is a path which leaves the loop: if %3 is false, the program will branch to block3 and return. However, a numerical analysis can prove that the product of any number and 2 will be even, which means that %2 is always zero and %3 can never be false. This function can therefore be optimized into this form:
<span id="mwBAk"></span><span class="k" id="mwBAo">define</span><span class="w" id="mwBAs"> </span><span class="k" id="mwBAw">void</span><span class="w" id="mwBA0"> </span><span class="vg" id="mwBA4">@double_until_odd</span><span class="p" id="mwBA8">(</span><span class="kt" id="mwBBA">ptr</span><span class="w" id="mwBBE"> </span><span class="nv" id="mwBBI">%p</span><span class="p" id="mwBBM">)</span><span class="w" id="mwBBQ"> </span><span class="p" id="mwBBU">{</span> <span class="nl" id="mwBBY">block1:</span> <span class="w" id="mwBBc"> </span><span class="k" id="mwBBg">br</span><span class="w" id="mwBBk"> </span><span class="kt" id="mwBBo">label</span><span class="w" id="mwBBs"> </span><span class="nv" id="mwBBw">%block2</span> <span class="nl" id="mwBB0">block2:</span> <span class="w" id="mwBB4"> </span><span class="nv nv-Anonymous" id="mwBB8">%0</span><span class="w" id="mwBCA"> </span><span class="p" id="mwBCE">=</span><span class="w" id="mwBCI"> </span><span class="k" id="mwBCM">load</span><span class="w" id="mwBCQ"> </span><span class="kt" id="mwBCU">i32</span><span class="p" id="mwBCY">,</span><span class="w" id="mwBCc"> </span><span class="kt" id="mwBCg">ptr</span><span class="w" id="mwBCk"> </span><span class="nv" id="mwBCo">%p</span><span class="w" id="mwBCs"> </span><span class="c" id="mwBCw">; Load the current value from %p</span> <span class="w" id="mwBC0"> </span><span class="nv nv-Anonymous" id="mwBC4">%1</span><span class="w" id="mwBC8"> </span><span class="p" id="mwBDA">=</span><span class="w" id="mwBDE"> </span><span class="k" id="mwBDI">mul</span><span class="w" id="mwBDM"> </span><span class="kt" id="mwBDQ">i32</span><span class="w" id="mwBDU"> </span><span class="nv nv-Anonymous" id="mwBDY">%0</span><span class="p" id="mwBDc">,</span><span class="w" id="mwBDg"> </span><span class="m" id="mwBDk">2</span><span class="w" id="mwBDo"> </span><span class="c" id="mwBDs">; Multiply it by 2</span> <span class="w" id="mwBDw"> </span><span class="k" id="mwBD0">store</span><span class="w" id="mwBD4"> </span><span class="kt" id="mwBD8">i32</span><span class="w" id="mwBEA"> </span><span class="nv nv-Anonymous" id="mwBEE">%1</span><span class="p" id="mwBEI">,</span><span class="w" id="mwBEM"> </span><span class="kt" id="mwBEQ">ptr</span><span class="w" id="mwBEU"> </span><span class="nv" id="mwBEY">%p</span><span class="w" id="mwBEc"> </span><span class="c" id="mwBEg">; Store that back into %p</span> <span class="w" id="mwBEk"> </span><span class="k" id="mwBEo">br</span><span class="w" id="mwBEs"> </span><span class="kt" id="mwBEw">label</span><span class="w" id="mwBE0"> </span><span class="nv" id="mwBE4">%block2</span> <span class="nl" id="mwBE8">block3:</span><span class="w" id="mwBFA"> </span><span class="c" id="mwBFE">; unreachable</span> <span class="w" id="mwBFI"> </span><span class="k" id="mwBFM">ret</span><span class="w" id="mwBFQ"> </span><span class="k" id="mwBFU">void</span> <span class="p" id="mwBFY">}</span>There is now an infinite loop in the control flow graph, and the exit block can no longer be reached. Note that this optimization did not change the behavior of the program: it was always true that the loop would never exit. All that has changed is that the control flow graph is more accurately reflecting that truth.
Dominance relationships
A block M dominates a block N if every path from the entry that reaches block N also has to visit block M. The entry block dominates all blocks. M is said to properly dominate N if M dominates N and they are different blocks. Furthermore, an individual statement or instruction X is said to properly dominate a statement or instruction Y if the block containing X dominates the block containing Y and, if those are the same block, X strictly precedes Y in the block.
It is said that a block M immediately dominates block N if M dominates N, and there is no intervening block P such that M dominates P and P dominates N. In other words, M is the last dominator on all paths from entry to N. Every reachable block has a unique immediate dominator except for the entry block, which has none.
The dominator tree is a directed graph representing the dominance relationships in the function. The nodes of the graph are the reachable basic blocks of the function, and there is an edge from block M to block N if M is an immediate dominator of N. Since each non-entry reachable block has a unique immediate dominator, this is a tree rooted at the entry block. The dominator tree can be calculated efficiently using Lengauer–Tarjan's algorithm.
In the reverse direction, block M post-dominates block N if every path from N to the exit also has to visit block M. (This is sometimes written without a hyphen: M postdominates N.) The exit block post-dominates all blocks. M is said to properly post-dominate N if it post-dominates N and they are different blocks. M is an immediate post-dominator of N if it post-dominates N and there is no block P such that M post-dominates P and P post-dominates N. Every block from which the exit block is reachable has a unique immediate post-dominator except for the exit block, which has none. This gives rise to a post-dominator tree, rooted at the exit block, over the blocks from which the exit block is reachable.
The standard definition of dominance includes unreachable blocks, and the standard definition of post-dominance includes blocks from which the exit block cannot be reached. However, such blocks have unique properties under these relationships: an unreachable block is dominated by all blocks, and a block from which the exit cannot be reached is post-dominated by all blocks. Most analyses relying on dominance or post-dominance will want to ignore them, and they are not included in dominator or post-dominator trees. Some representations require the addition of impossible edges to prevent these blocks from existing, at least formally.
Special edges
A critical edge is an edge which is neither the only edge leaving its source block, nor the only edge entering its destination block. Some optimizations must split critical edges in order to insert instructions along the edge without affecting other paths through the program. An edge is split by creating a new block that contains only a jump to the destination block, then replacing the original branch destination with the new block.
A retreating edge is an edge for which there exists a simple path from the entry block to the source block of the edge (such as might be found by a depth-first traversal of the graph) which includes the destination block. A retreating edge indicates the presence of a cycle in the control flow graph. A retreating edge is called a back edge if the destination block is present on all possible paths to the source block, which is to say, if the destination block dominates the source block.
An abnormal edge is an edge whose destination is unknown. Exception handling constructs can produce them. These edges tend to inhibit optimization.
An impossible edge (also known as a fake edge) is an edge which cannot actually be traversed during execution and is only added to the graph to preserve some useful property. For example, some representations require the addition of impossible edges to ensure that the exit block is always reachable and post-dominates all blocks.
Strongly-connected components
A strongly-connected component (SCC) of a control flow graph is a set of basic blocks which are all reachable from one another. The blocks that are part of a loop are always part of the same strongly-connected component. A block that is not part of a cycle is always in a strongly-connected component by itself. In particular, the entry and exit blocks are always their own strongly-connected components.
The strongly-connected components of a CFG form a directed acyclic graph called the SCC tree, where component A has an edge to component B if any block in A has an edge to any block in B. The SCC tree is isomorphic to the control flow graph if there are no cycles in the CFG; if there is a cycle, the SCC tree essentially collapses all blocks and edges in it into a single node. This can be useful for analyses that wish to treat all of the blocks in a cycle as equivalent. For example, when trying to find an object lifetime that covers a set of use-points as narrowly as possible, if one of those use-points is within a cyclic SCC, the lifetime must fully cover every block in that component.
Loop management
A loop header (sometimes called the entry point of the loop) is a dominator that is the target of a loop-forming back edge. The loop header dominates all blocks in the loop body. A block may be a loop header for more than one loop. A loop may have multiple entry points, in which case it has no "loop header".
Suppose block M is a dominator with several incoming edges, some of them being back edges (so M is a loop header). It is advantageous to several optimization passes to break M up into two blocks Mpre and Mloop. The contents of M and back edges are moved to Mloop, the rest of the edges are moved to point into Mpre, and a new edge from Mpre to Mloop is inserted (so that Mpre is the immediate dominator of Mloop). In the beginning, Mpre would be empty, but passes like loop-invariant code motion could populate it. Mpre is called the loop pre-header, and Mloop would be the loop header.
Reducibility
A control flow graph is called reducible if all its retreating edges are back edges. The other edges in such a CFG are called forward edges. The forward edges form a directed acyclic graph, and the back edges always lead to a basic block that control flow has already passed through. Reducible CFGs generally have stronger static properties and can be more easily analyzed and optimized. For example, many loop optimizations are designed to work only on reducible CFGs.
Structured programming languages are often designed such that all CFGs they produce are reducible, and common structured programming statements such as IF, FOR, WHILE, BREAK, and CONTINUE reliably produce reducible graphs. To directly produce an irreducible graph, statements such as GOTO are needed that can jump to an arbitrary point in the program, although not all uses of GOTO produce irreducible CFGs. Irreducible CFGs can also be produced by some compiler optimizations, such as jump threading. Irreducible CFGs can be converted to reducible CFGs, but this often requires duplicating code or introducing new variables to the program.
Loop connectedness
The loop connectedness of a CFG is defined with respect to a given depth-first search tree (DFST) of the CFG. This DFST should be rooted at the start node and cover every node of the CFG.
In this context, edges in the CFG which run from a node to one of its DFST ancestors (including itself) are called back edges. This does not necessarily coincide with the usual definition of a back edge because a DFST ancestor need not dominate the source node of the edge.
The loop connectedness is the largest number of back edges found in any cycle-free path of the CFG. In a reducible CFG, the loop connectedness is independent of the DFST chosen.
Loop connectedness has been used to reason about the time complexity of data-flow analysis.
Inter-procedural control-flow graph
While control-flow graphs represent the control flow of a single procedure, inter-procedural control-flow graphs represent the control flow of whole programs.