<html lang="en"> <head> <title>SSA - GNU Compiler Collection (GCC) Internals</title> <meta http-equiv="Content-Type" content="text/html"> <meta name="description" content="GNU Compiler Collection (GCC) Internals"> <meta name="generator" content="makeinfo 4.13"> <link title="Top" rel="start" href="index.html#Top"> <link rel="up" href="Tree-SSA.html#Tree-SSA" title="Tree SSA"> <link rel="prev" href="SSA-Operands.html#SSA-Operands" title="SSA Operands"> <link rel="next" href="Alias-analysis.html#Alias-analysis" title="Alias analysis"> <link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage"> <!-- Copyright (C) 1988-2015 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being ``Funding Free Software'', the Front-Cover Texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in the section entitled ``GNU Free Documentation License''. (a) The FSF's Front-Cover Text is: A GNU Manual (b) The FSF's Back-Cover Text is: You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development.--> <meta http-equiv="Content-Style-Type" content="text/css"> <style type="text/css"><!-- pre.display { font-family:inherit } pre.format { font-family:inherit } pre.smalldisplay { font-family:inherit; font-size:smaller } pre.smallformat { font-family:inherit; font-size:smaller } pre.smallexample { font-size:smaller } pre.smalllisp { font-size:smaller } span.sc { font-variant:small-caps } span.roman { font-family:serif; font-weight:normal; } span.sansserif { font-family:sans-serif; font-weight:normal; } --></style> </head> <body> <div class="node"> <a name="SSA"></a> <p> Next: <a rel="next" accesskey="n" href="Alias-analysis.html#Alias-analysis">Alias analysis</a>, Previous: <a rel="previous" accesskey="p" href="SSA-Operands.html#SSA-Operands">SSA Operands</a>, Up: <a rel="up" accesskey="u" href="Tree-SSA.html#Tree-SSA">Tree SSA</a> <hr> </div> <h3 class="section">12.3 Static Single Assignment</h3> <p><a name="index-SSA-2515"></a><a name="index-static-single-assignment-2516"></a> Most of the tree optimizers rely on the data flow information provided by the Static Single Assignment (SSA) form. We implement the SSA form as described in <cite>R. Cytron, J. Ferrante, B. Rosen, M. Wegman, and K. Zadeck. Efficiently Computing Static Single Assignment Form and the Control Dependence Graph. ACM Transactions on Programming Languages and Systems, 13(4):451-490, October 1991</cite>. <p>The SSA form is based on the premise that program variables are assigned in exactly one location in the program. Multiple assignments to the same variable create new versions of that variable. Naturally, actual programs are seldom in SSA form initially because variables tend to be assigned multiple times. The compiler modifies the program representation so that every time a variable is assigned in the code, a new version of the variable is created. Different versions of the same variable are distinguished by subscripting the variable name with its version number. Variables used in the right-hand side of expressions are renamed so that their version number matches that of the most recent assignment. <p>We represent variable versions using <code>SSA_NAME</code> nodes. The renaming process in <samp><span class="file">tree-ssa.c</span></samp> wraps every real and virtual operand with an <code>SSA_NAME</code> node which contains the version number and the statement that created the <code>SSA_NAME</code>. Only definitions and virtual definitions may create new <code>SSA_NAME</code> nodes. <p><a name="index-PHI-nodes-2517"></a>Sometimes, flow of control makes it impossible to determine the most recent version of a variable. In these cases, the compiler inserts an artificial definition for that variable called <dfn>PHI function</dfn> or <dfn>PHI node</dfn>. This new definition merges all the incoming versions of the variable to create a new name for it. For instance, <pre class="smallexample"> if (...) a_1 = 5; else if (...) a_2 = 2; else a_3 = 13; # a_4 = PHI <a_1, a_2, a_3> return a_4; </pre> <p>Since it is not possible to determine which of the three branches will be taken at runtime, we don't know which of <code>a_1</code>, <code>a_2</code> or <code>a_3</code> to use at the return statement. So, the SSA renamer creates a new version <code>a_4</code> which is assigned the result of “merging” <code>a_1</code>, <code>a_2</code> and <code>a_3</code>. Hence, PHI nodes mean “one of these operands. I don't know which”. <p>The following functions can be used to examine PHI nodes <div class="defun"> — Function: <b>gimple_phi_result</b> (<var>phi</var>)<var><a name="index-gimple_005fphi_005fresult-2518"></a></var><br> <blockquote><p>Returns the <code>SSA_NAME</code> created by PHI node <var>phi</var> (i.e., <var>phi</var>'s LHS). </p></blockquote></div> <div class="defun"> — Function: <b>gimple_phi_num_args</b> (<var>phi</var>)<var><a name="index-gimple_005fphi_005fnum_005fargs-2519"></a></var><br> <blockquote><p>Returns the number of arguments in <var>phi</var>. This number is exactly the number of incoming edges to the basic block holding <var>phi</var>. </p></blockquote></div> <div class="defun"> — Function: <b>gimple_phi_arg</b> (<var>phi, i</var>)<var><a name="index-gimple_005fphi_005farg-2520"></a></var><br> <blockquote><p>Returns <var>i</var>th argument of <var>phi</var>. </p></blockquote></div> <div class="defun"> — Function: <b>gimple_phi_arg_edge</b> (<var>phi, i</var>)<var><a name="index-gimple_005fphi_005farg_005fedge-2521"></a></var><br> <blockquote><p>Returns the incoming edge for the <var>i</var>th argument of <var>phi</var>. </p></blockquote></div> <div class="defun"> — Function: <b>gimple_phi_arg_def</b> (<var>phi, i</var>)<var><a name="index-gimple_005fphi_005farg_005fdef-2522"></a></var><br> <blockquote><p>Returns the <code>SSA_NAME</code> for the <var>i</var>th argument of <var>phi</var>. </p></blockquote></div> <h4 class="subsection">12.3.1 Preserving the SSA form</h4> <p><a name="index-update_005fssa-2523"></a><a name="index-preserving-SSA-form-2524"></a>Some optimization passes make changes to the function that invalidate the SSA property. This can happen when a pass has added new symbols or changed the program so that variables that were previously aliased aren't anymore. Whenever something like this happens, the affected symbols must be renamed into SSA form again. Transformations that emit new code or replicate existing statements will also need to update the SSA form. <p>Since GCC implements two different SSA forms for register and virtual variables, keeping the SSA form up to date depends on whether you are updating register or virtual names. In both cases, the general idea behind incremental SSA updates is similar: when new SSA names are created, they typically are meant to replace other existing names in the program. <p>For instance, given the following code: <pre class="smallexample"> 1 L0: 2 x_1 = PHI (0, x_5) 3 if (x_1 < 10) 4 if (x_1 > 7) 5 y_2 = 0 6 else 7 y_3 = x_1 + x_7 8 endif 9 x_5 = x_1 + 1 10 goto L0; 11 endif </pre> <p>Suppose that we insert new names <code>x_10</code> and <code>x_11</code> (lines <code>4</code> and <code>8</code>). <pre class="smallexample"> 1 L0: 2 x_1 = PHI (0, x_5) 3 if (x_1 < 10) 4 x_10 = ... 5 if (x_1 > 7) 6 y_2 = 0 7 else 8 x_11 = ... 9 y_3 = x_1 + x_7 10 endif 11 x_5 = x_1 + 1 12 goto L0; 13 endif </pre> <p>We want to replace all the uses of <code>x_1</code> with the new definitions of <code>x_10</code> and <code>x_11</code>. Note that the only uses that should be replaced are those at lines <code>5</code>, <code>9</code> and <code>11</code>. Also, the use of <code>x_7</code> at line <code>9</code> should <em>not</em> be replaced (this is why we cannot just mark symbol <code>x</code> for renaming). <p>Additionally, we may need to insert a PHI node at line <code>11</code> because that is a merge point for <code>x_10</code> and <code>x_11</code>. So the use of <code>x_1</code> at line <code>11</code> will be replaced with the new PHI node. The insertion of PHI nodes is optional. They are not strictly necessary to preserve the SSA form, and depending on what the caller inserted, they may not even be useful for the optimizers. <p>Updating the SSA form is a two step process. First, the pass has to identify which names need to be updated and/or which symbols need to be renamed into SSA form for the first time. When new names are introduced to replace existing names in the program, the mapping between the old and the new names are registered by calling <code>register_new_name_mapping</code> (note that if your pass creates new code by duplicating basic blocks, the call to <code>tree_duplicate_bb</code> will set up the necessary mappings automatically). <p>After the replacement mappings have been registered and new symbols marked for renaming, a call to <code>update_ssa</code> makes the registered changes. This can be done with an explicit call or by creating <code>TODO</code> flags in the <code>tree_opt_pass</code> structure for your pass. There are several <code>TODO</code> flags that control the behavior of <code>update_ssa</code>: <ul> <li><code>TODO_update_ssa</code>. Update the SSA form inserting PHI nodes for newly exposed symbols and virtual names marked for updating. When updating real names, only insert PHI nodes for a real name <code>O_j</code> in blocks reached by all the new and old definitions for <code>O_j</code>. If the iterated dominance frontier for <code>O_j</code> is not pruned, we may end up inserting PHI nodes in blocks that have one or more edges with no incoming definition for <code>O_j</code>. This would lead to uninitialized warnings for <code>O_j</code>'s symbol. <li><code>TODO_update_ssa_no_phi</code>. Update the SSA form without inserting any new PHI nodes at all. This is used by passes that have either inserted all the PHI nodes themselves or passes that need only to patch use-def and def-def chains for virtuals (e.g., DCE). <li><code>TODO_update_ssa_full_phi</code>. Insert PHI nodes everywhere they are needed. No pruning of the IDF is done. This is used by passes that need the PHI nodes for <code>O_j</code> even if it means that some arguments will come from the default definition of <code>O_j</code>'s symbol (e.g., <code>pass_linear_transform</code>). <p>WARNING: If you need to use this flag, chances are that your pass may be doing something wrong. Inserting PHI nodes for an old name where not all edges carry a new replacement may lead to silent codegen errors or spurious uninitialized warnings. <li><code>TODO_update_ssa_only_virtuals</code>. Passes that update the SSA form on their own may want to delegate the updating of virtual names to the generic updater. Since FUD chains are easier to maintain, this simplifies the work they need to do. NOTE: If this flag is used, any OLD->NEW mappings for real names are explicitly destroyed and only the symbols marked for renaming are processed. </ul> <h4 class="subsection">12.3.2 Preserving the virtual SSA form</h4> <p><a name="index-preserving-virtual-SSA-form-2525"></a> The virtual SSA form is harder to preserve than the non-virtual SSA form mainly because the set of virtual operands for a statement may change at what some would consider unexpected times. In general, statement modifications should be bracketed between calls to <code>push_stmt_changes</code> and <code>pop_stmt_changes</code>. For example, <pre class="smallexample"> munge_stmt (tree stmt) { push_stmt_changes (&stmt); ... rewrite STMT ... pop_stmt_changes (&stmt); } </pre> <p>The call to <code>push_stmt_changes</code> saves the current state of the statement operands and the call to <code>pop_stmt_changes</code> compares the saved state with the current one and does the appropriate symbol marking for the SSA renamer. <p>It is possible to modify several statements at a time, provided that <code>push_stmt_changes</code> and <code>pop_stmt_changes</code> are called in LIFO order, as when processing a stack of statements. <p>Additionally, if the pass discovers that it did not need to make changes to the statement after calling <code>push_stmt_changes</code>, it can simply discard the topmost change buffer by calling <code>discard_stmt_changes</code>. This will avoid the expensive operand re-scan operation and the buffer comparison that determines if symbols need to be marked for renaming. <h4 class="subsection">12.3.3 Examining <code>SSA_NAME</code> nodes</h4> <p><a name="index-examining-SSA_005fNAMEs-2526"></a> The following macros can be used to examine <code>SSA_NAME</code> nodes <div class="defun"> — Macro: <b>SSA_NAME_DEF_STMT</b> (<var>var</var>)<var><a name="index-SSA_005fNAME_005fDEF_005fSTMT-2527"></a></var><br> <blockquote><p>Returns the statement <var>s</var> that creates the <code>SSA_NAME</code> <var>var</var>. If <var>s</var> is an empty statement (i.e., <code>IS_EMPTY_STMT (</code><var>s</var><code>)</code> returns <code>true</code>), it means that the first reference to this variable is a USE or a VUSE. </p></blockquote></div> <div class="defun"> — Macro: <b>SSA_NAME_VERSION</b> (<var>var</var>)<var><a name="index-SSA_005fNAME_005fVERSION-2528"></a></var><br> <blockquote><p>Returns the version number of the <code>SSA_NAME</code> object <var>var</var>. </p></blockquote></div> <h4 class="subsection">12.3.4 Walking the dominator tree</h4> <div class="defun"> — Tree SSA function: void <b>walk_dominator_tree</b> (<var>walk_data, bb</var>)<var><a name="index-walk_005fdominator_005ftree-2529"></a></var><br> <blockquote> <p>This function walks the dominator tree for the current CFG calling a set of callback functions defined in <var>struct dom_walk_data</var> in <samp><span class="file">domwalk.h</span></samp>. The call back functions you need to define give you hooks to execute custom code at various points during traversal: <ol type=1 start=1> <li>Once to initialize any local data needed while processing <var>bb</var> and its children. This local data is pushed into an internal stack which is automatically pushed and popped as the walker traverses the dominator tree. <li>Once before traversing all the statements in the <var>bb</var>. <li>Once for every statement inside <var>bb</var>. <li>Once after traversing all the statements and before recursing into <var>bb</var>'s dominator children. <li>It then recurses into all the dominator children of <var>bb</var>. <li>After recursing into all the dominator children of <var>bb</var> it can, optionally, traverse every statement in <var>bb</var> again (i.e., repeating steps 2 and 3). <li>Once after walking the statements in <var>bb</var> and <var>bb</var>'s dominator children. At this stage, the block local data stack is popped. </ol> </p></blockquote></div> </body></html>