Analysis and Optimization of GIMPLE tuples
******************************************

GCC uses three main intermediate languages to represent the program during compilation: GENERIC, GIMPLE and RTL.  GENERIC is a language-independent representation generated by each front end.  It is used to serve as an interface between the parser and optimizer. GENERIC is a common representation that is able to represent programs written in all the languages supported by GCC.

GIMPLE and RTL are used to optimize the program.  GIMPLE is used for target and language independent optimizations (e.g., inlining, constant propagation, tail call elimination, redundancy elimination, etc).  Much like GENERIC, GIMPLE is a language independent, tree based representation.  However, it differs from GENERIC in that the GIMPLE grammar is more restrictive: expressions contain no more than 3 operands (except function calls), it has no control flow structures and expressions with side-effects are only allowed on the right hand side of assignments.  See the chapter describing GENERIC and GIMPLE for more details.

This chapter describes the data structures and functions used in the GIMPLE optimizers (also known as ``tree optimizers'' or ``middle end'').  In particular, it focuses on all the macros, data structures, functions and programming constructs needed to implement optimization passes for GIMPLE.

Annotations
===========

The optimizers need to associate attributes with variables during the optimization process.  For instance, we need to know whether a variable has aliases.  All these attributes are stored in data structures called annotations which are then linked to the field ann in struct tree_common.

SSA Operands
============

Almost every GIMPLE statement will contain a reference to a variable or memory location.  Since statements come in different shapes and sizes, their operands are going to be located at various spots inside the statement's tree.  To facilitate access to the statement's operands, they are organized into lists associated inside each statement's annotation.  Each element in an operand list is a pointer to a VAR_DECL, PARM_DECL or SSA_NAME tree node. This provides a very convenient way of examining and replacing operands.

Data flow analysis and optimization is done on all tree nodes representing variables.  Any node for which SSA_VAR_P returns nonzero is considered when scanning statement operands.  However, not all SSA_VAR_P variables are processed in the same way.  For the purposes of optimization, we need to distinguish between references to local scalar variables and references to globals, statics, structures, arrays, aliased variables, etc.  The reason is simple, the compiler can gather complete data flow information for a local scalar.  On the other hand, a global variable may be modified by a function call, it may not be possible to keep track of all the elements of an array or the fields of a structure, etc.

The operand scanner gathers two kinds of operands: real and virtual.  An operand for which is_gimple_reg returns true is considered real, otherwise it is a virtual operand.  We also distinguish between uses and definitions.  An operand is used if its value is loaded by the statement (e.g., the operand at the RHS of an assignment).  If the statement assigns a new value to the operand, the operand is considered a definition (e.g., the operand at the LHS of an assignment).

Virtual and real operands also have very different data flow properties.  Real operands are unambiguous references to the full object that they represent.  For instance, given

     {
       int a, b;
       a = b
     }

Since a and b are non-aliased locals, the statement a = b will have one real definition and one real use because variable a is completely modified with the contents of variable b.  Real definition are also known as killing definitions.  Similarly, the use of b reads all its bits.

In contrast, virtual operands are used with variables that can have a partial or ambiguous reference.  This includes structures, arrays, globals, and aliased variables.  In these cases, we have two types of definitions.  For globals, structures, and arrays, we can determine from a statement whether a variable of these types has a killing definition. If the variable does, then the statement is marked as having a must definition of that variable.  However, if a statement is only defining a part of the variable (i.e. a field in a structure), or if we know that a statement might define the variable but we cannot say for sure, then we mark that statement as having a may definition.  For instance, given

     {
       int a, b, *p;

       if (...)
         p = &a;
       else
         p = &b;
       *p = 5;
       return *p;
     }

The assignment *p = 5 may be a definition of a or b.  If we cannot determine statically where p is pointing to at the time of the store operation, we create virtual definitions to mark that statement as a potential definition site for a and b.  Memory loads are similarly marked with virtual use operands.  Virtual operands are shown in tree dumps right before the statement that contains them.  To request a tree dump with virtual operands, use the -vops option to -fdump-tree:

     {
       int a, b, *p;

       if (...)
         p = &a;
       else
         p = &b;
       # a = VDEF <a>
       # b = VDEF <b>
       *p = 5;

       # VUSE <a>
       # VUSE <b>
       return *p;
     }

Notice that VDEF operands have two copies of the referenced variable.  This indicates that this is not a killing definition of that variable.  In this case we refer to it as a may definition or aliased store.  The presence of the second copy of the variable in the VDEF operand will become important when the function is converted into SSA form.  This will be used to link all the non-killing definitions to prevent optimizations from making incorrect assumptions about them.

Operands are updated as soon as the statement is finished via a call to update_stmt.  If statement elements are changed via SET_USE or SET_DEF, then no further action is required (i.e., those macros take care of updating the statement).  If changes are made by manipulating the statement's tree directly, then a call must be made to update_stmt when complete.  Calling one of the bsi_insert routines or bsi_replace performs an implicit call to update_stmt.

Operand Iterators And Access Routines
-------------------------------------

Operands are collected by tree-ssa-operands.c.  They are stored inside each statement's annotation and can be accessed through either the operand iterators or an access routine.

The following access routines are available for examining operands:

 1. SINGLE_SSA_{USE,DEF,TREE}_OPERAND: These accessors will return NULL unless there is exactly one operand matching the specified flags.  If there is exactly one operand, the operand is returned as either a tree, def_operand_p, or use_operand_p.

          tree t = SINGLE_SSA_TREE_OPERAND (stmt, flags);
          use_operand_p u = SINGLE_SSA_USE_OPERAND (stmt, SSA_ALL_VIRTUAL_USES);
          def_operand_p d = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_ALL_DEFS);

 2. ZERO_SSA_OPERANDS: This macro returns true if there are no operands matching the specified flags.

          if (ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
            return;

 3. NUM_SSA_OPERANDS: This macro Returns the number of operands matching 'flags'.  This actually executes a loop to perform the count, so only use this if it is really needed.

          int count = NUM_SSA_OPERANDS (stmt, flags)

If you wish to iterate over some or all operands, use the FOR_EACH_SSA_{USE,DEF,TREE}_OPERAND iterator.  For example, to print all the operands for a statement:

     void
     print_ops (tree stmt)
     {
       ssa_op_iter;
       tree var;

       FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_OPERANDS)
         print_generic_expr (stderr, var, TDF_SLIM);
     }

How to choose the appropriate iterator:

 1. Determine whether you are need to see the operand pointers, or just the trees, and choose the appropriate macro:

          Need            Macro:
          ----            -------
          use_operand_p   FOR_EACH_SSA_USE_OPERAND
          def_operand_p   FOR_EACH_SSA_DEF_OPERAND
          tree            FOR_EACH_SSA_TREE_OPERAND

 2. You need to declare a variable of the type you are interested in, and an ssa_op_iter structure which serves as the loop controlling variable.

 3. Determine which operands you wish to use, and specify the flags of those you are interested in.  They are documented in tree-ssa-operands.h:

          #define SSA_OP_USE              0x01    /* Real USE operands.  */
          #define SSA_OP_DEF              0x02    /* Real DEF operands.  */
          #define SSA_OP_VUSE             0x04    /* VUSE operands.  */
          #define SSA_OP_VDEF             0x08    /* VDEF operands.  */

          /* These are commonly grouped operand flags.  */
          #define SSA_OP_VIRTUAL_USES	(SSA_OP_VUSE)
          #define SSA_OP_VIRTUAL_DEFS	(SSA_OP_VDEF)
          #define SSA_OP_ALL_VIRTUALS     (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_DEFS)
          #define SSA_OP_ALL_USES		(SSA_OP_VIRTUAL_USES | SSA_OP_USE)
          #define SSA_OP_ALL_DEFS		(SSA_OP_VIRTUAL_DEFS | SSA_OP_DEF)
          #define SSA_OP_ALL_OPERANDS	(SSA_OP_ALL_USES | SSA_OP_ALL_DEFS)

So if you want to look at the use pointers for all the USE and VUSE operands, you would do something like:

       use_operand_p use_p;
       ssa_op_iter iter;

       FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, (SSA_OP_USE | SSA_OP_VUSE))
         {
           process_use_ptr (use_p);
         }

The TREE macro is basically the same as the USE and DEF macros, only with the use or def dereferenced via USE_FROM_PTR (use_p) and DEF_FROM_PTR (def_p).  Since we aren't using operand pointers, use and defs flags can be mixed.

       tree var;
       ssa_op_iter iter;

       FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_VUSE)
         {
            print_generic_expr (stderr, var, TDF_SLIM);
         }

VDEFs are broken into two flags, one for the DEF portion (SSA_OP_VDEF) and one for the USE portion (SSA_OP_VUSE).

There are many examples in the code, in addition to the documentation in tree-ssa-operands.h and ssa-iterators.h.

There are also a couple of variants on the stmt iterators regarding PHI nodes.

FOR_EACH_PHI_ARG Works exactly like FOR_EACH_SSA_USE_OPERAND, except it works over PHI arguments instead of statement operands.

     /* Look at every virtual PHI use.  */
     FOR_EACH_PHI_ARG (use_p, phi_stmt, iter, SSA_OP_VIRTUAL_USES)
     {
        my_code;
     }

     /* Look at every real PHI use.  */
     FOR_EACH_PHI_ARG (use_p, phi_stmt, iter, SSA_OP_USES)
       my_code;

     /* Look at every PHI use.  */
     FOR_EACH_PHI_ARG (use_p, phi_stmt, iter, SSA_OP_ALL_USES)
       my_code;

FOR_EACH_PHI_OR_STMT_{USE,DEF} works exactly like FOR_EACH_SSA_{USE,DEF}_OPERAND, except it will function on either a statement or a PHI node.  These should be used when it is appropriate but they are not quite as efficient as the individual FOR_EACH_PHI and FOR_EACH_SSA routines.

     FOR_EACH_PHI_OR_STMT_USE (use_operand_p, stmt, iter, flags)
       {
          my_code;
       }

     FOR_EACH_PHI_OR_STMT_DEF (def_operand_p, phi, iter, flags)
       {
          my_code;
       }

Immediate Uses
--------------

Immediate use information is now always available.  Using the immediate use iterators, you may examine every use of any SSA_NAME. For instance, to change each use of ssa_var to ssa_var2 and call fold_stmt on each stmt after that is done:

       use_operand_p imm_use_p;
       imm_use_iterator iterator;
       tree ssa_var, stmt;

       FOR_EACH_IMM_USE_STMT (stmt, iterator, ssa_var)
         {
           FOR_EACH_IMM_USE_ON_STMT (imm_use_p, iterator)
             SET_USE (imm_use_p, ssa_var_2);
           fold_stmt (stmt);
         }

There are 2 iterators which can be used. FOR_EACH_IMM_USE_FAST is used when the immediate uses are not changed, i.e., you are looking at the uses, but not setting them.

If they do get changed, then care must be taken that things are not changed under the iterators, so use the FOR_EACH_IMM_USE_STMT and FOR_EACH_IMM_USE_ON_STMT iterators.  They attempt to preserve the sanity of the use list by moving all the uses for a statement into a controlled position, and then iterating over those uses.  Then the optimization can manipulate the stmt when all the uses have been processed.  This is a little slower than the FAST version since it adds a placeholder element and must sort through the list a bit for each statement. This placeholder element must be also be removed if the loop is terminated early.  The macro BREAK_FROM_IMM_USE_SAFE is provided to do this :

       FOR_EACH_IMM_USE_STMT (stmt, iterator, ssa_var)
         {
           if (stmt == last_stmt)
             BREAK_FROM_SAFE_IMM_USE (iter);

           FOR_EACH_IMM_USE_ON_STMT (imm_use_p, iterator)
             SET_USE (imm_use_p, ssa_var_2);
           fold_stmt (stmt);
         }

There are checks in verify_ssa which verify that the immediate use list is up to date, as well as checking that an optimization didn't break from the loop without using this macro.  It is safe to simply 'break'; from a FOR_EACH_IMM_USE_FAST traverse.

Some useful functions and macros:

 1. has_zero_uses (ssa_var) : Returns true if there are no uses of ssa_var.

 2. has_single_use (ssa_var) : Returns true if there is only a single use of ssa_var.

 3. single_imm_use (ssa_var, use_operand_p *ptr, tree *stmt) : Returns true if there is only a single use of ssa_var, and also returns the use pointer and statement it occurs in, in the second and third parameters.

 4. num_imm_uses (ssa_var) : Returns the number of immediate uses of ssa_var. It is better not to use this if possible since it simply utilizes a loop to count the uses.

 5. PHI_ARG_INDEX_FROM_USE (use_p) : Given a use within a PHI node, return the index number for the use.  An assert is triggered if the use isn't located in a PHI node.

 6. USE_STMT (use_p) : Return the statement a use occurs in.

Note that uses are not put into an immediate use list until their statement is actually inserted into the instruction stream via a bsi_* routine.

It is also still possible to utilize lazy updating of statements, but this should be used only when absolutely required.  Both alias analysis and the dominator optimizations currently do this.

When lazy updating is being used, the immediate use information is out of date and cannot be used reliably.  Lazy updating is achieved by simply marking statements modified via calls to mark_stmt_modified instead of update_stmt.  When lazy updating is no longer required, all the modified statements must have update_stmt called in order to bring them up to date.  This must be done before the optimization is finished, or verify_ssa will trigger an abort.

This is done with a simple loop over the instruction stream:

       block_stmt_iterator bsi;
       basic_block bb;
       FOR_EACH_BB (bb)
         {
           for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
             update_stmt_if_modified (bsi_stmt (bsi));
         }

Static Single Assignment
========================

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 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.

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.

We represent variable versions using SSA_NAME nodes.  The renaming process in tree-ssa.c wraps every real and virtual operand with an SSA_NAME node which contains the version number and the statement that created the SSA_NAME.  Only definitions and virtual definitions may create new SSA_NAME nodes.

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 PHI function or PHI node.  This new definition merges all the incoming versions of the variable to create a new name for it.  For instance,

     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;

Since it is not possible to determine which of the three branches will be taken at runtime, we don't know which of a_1, a_2 or a_3 to use at the return statement.  So, the SSA renamer creates a new version a_4 which is assigned the result of ``merging'' a_1, a_2 and a_3. Hence, PHI nodes mean ``one of these operands.  I don't know which''.

The following functions can be used to examine PHI nodes

 -- Function: gimple_phi_result (PHI)
     Returns the SSA_NAME created by PHI node PHI (i.e., PHI's LHS).

 -- Function: gimple_phi_num_args (PHI)
     Returns the number of arguments in PHI.  This number is exactly the number of incoming edges to the basic block holding PHI.

 -- Function: gimple_phi_arg (PHI, I)
     Returns Ith argument of PHI.

 -- Function: gimple_phi_arg_edge (PHI, I)
     Returns the incoming edge for the Ith argument of PHI.

 -- Function: gimple_phi_arg_def (PHI, I)
     Returns the SSA_NAME for the Ith argument of PHI.

Preserving the SSA form
-----------------------

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.

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.

For instance, given the following code:

          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

Suppose that we insert new names x_10 and x_11 (lines 4 and 8).

          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

We want to replace all the uses of x_1 with the new definitions of x_10 and x_11.  Note that the only uses that should be replaced are those at lines 5, 9 and 11. Also, the use of x_7 at line 9 should not be replaced (this is why we cannot just mark symbol x for renaming).

Additionally, we may need to insert a PHI node at line 11 because that is a merge point for x_10 and x_11.  So the use of x_1 at line 11 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.

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 register_new_name_mapping (note that if your pass creates new code by duplicating basic blocks, the call to tree_duplicate_bb will set up the necessary mappings automatically).

After the replacement mappings have been registered and new symbols marked for renaming, a call to update_ssa makes the registered changes.  This can be done with an explicit call or by creating TODO flags in the tree_opt_pass structure for your pass. There are several TODO flags that control the behavior of update_ssa:

  * TODO_update_ssa.  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 O_j in blocks reached by all the new and old definitions for O_j.  If the iterated dominance frontier for O_j is not pruned, we may end up inserting PHI nodes in blocks that have one or more edges with no incoming definition for O_j.  This would lead to uninitialized warnings for O_j's symbol.

  * TODO_update_ssa_no_phi.  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).

  * TODO_update_ssa_full_phi.  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 O_j even if it means that some arguments will come from the default definition of O_j's symbol (e.g., pass_linear_transform).

     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.

  * TODO_update_ssa_only_virtuals.  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.

Preserving the virtual SSA form
-------------------------------

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 push_stmt_changes and pop_stmt_changes.  For example,

         munge_stmt (tree stmt)
         {
            push_stmt_changes (&stmt);
            ... rewrite STMT ...
            pop_stmt_changes (&stmt);
         }

The call to push_stmt_changes saves the current state of the statement operands and the call to pop_stmt_changes compares the saved state with the current one and does the appropriate symbol marking for the SSA renamer.

It is possible to modify several statements at a time, provided that push_stmt_changes and pop_stmt_changes are called in LIFO order, as when processing a stack of statements.

Additionally, if the pass discovers that it did not need to make changes to the statement after calling push_stmt_changes, it can simply discard the topmost change buffer by calling discard_stmt_changes.  This will avoid the expensive operand re-scan operation and the buffer comparison that determines if symbols need to be marked for renaming.

Examining SSA_NAME nodes
------------------------

The following macros can be used to examine SSA_NAME nodes

 -- Macro: SSA_NAME_DEF_STMT (VAR)
     Returns the statement S that creates the SSA_NAME VAR.  If S is an empty statement (i.e., IS_EMPTY_STMT (S) returns true), it means that the first reference to this variable is a USE or a VUSE.

 -- Macro: SSA_NAME_VERSION (VAR)
     Returns the version number of the SSA_NAME object VAR.

Walking the dominator tree
--------------------------

 -- Tree SSA function: void walk_dominator_tree (WALK_DATA, BB)

     This function walks the dominator tree for the current CFG calling a set of callback functions defined in STRUCT DOM_WALK_DATA in domwalk.h.  The call back functions you need to define give you hooks to execute custom code at various points during traversal:

      1. Once to initialize any local data needed while processing BB 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.

      2. Once before traversing all the statements in the BB.

      3. Once for every statement inside BB.

      4. Once after traversing all the statements and before recursing into BB's dominator children.

      5. It then recurses into all the dominator children of BB.

      6. After recursing into all the dominator children of BB it can, optionally, traverse every statement in BB again (i.e., repeating steps 2 and 3).

      7. Once after walking the statements in BB and BB's dominator children.  At this stage, the block local data stack is popped.

Alias analysis
==============

Alias analysis in GIMPLE SSA form consists of two pieces.  First the virtual SSA web ties conflicting memory accesses and provides a SSA use-def chain and SSA immediate-use chains for walking possibly dependent memory accesses.  Second an alias-oracle can be queried to disambiguate explicit and implicit memory references.

 1. Memory SSA form.

     All statements that may use memory have exactly one accompanied use of a virtual SSA name that represents the state of memory at the given point in the IL.

     All statements that may define memory have exactly one accompanied definition of a virtual SSA name using the previous state of memory and defining the new state of memory after the given point in the IL.

          int i;
          int foo (void)
          {
            # .MEM_3 = VDEF <.MEM_2(D)>
            i = 1;
            # VUSE <.MEM_3>
            return i;
          }

     The virtual SSA names in this case are .MEM_2(D) and .MEM_3.  The store to the global variable i defines .MEM_3 invalidating .MEM_2(D).  The load from i uses that new state .MEM_3.

     The virtual SSA web serves as constraints to SSA optimizers preventing illegitimate code-motion and optimization.  It also provides a way to walk related memory statements.

 2. Points-to and escape analysis.

     Points-to analysis builds a set of constraints from the GIMPLE SSA IL representing all pointer operations and facts we do or do not know about pointers.  Solving this set of constraints yields a conservatively correct solution for each pointer variable in the program (though we are only interested in SSA name pointers) as to what it may possibly point to.

     This points-to solution for a given SSA name pointer is stored in the pt_solution sub-structure of the SSA_NAME_PTR_INFO record.  The following accessor functions are available:

       * pt_solution_includes

       * pt_solutions_intersect

     Points-to analysis also computes the solution for two special set of pointers, ESCAPED and CALLUSED.  Those represent all memory that has escaped the scope of analysis or that is used by pure or nested const calls.

 3. Type-based alias analysis

     Type-based alias analysis is frontend dependent though generic support is provided by the middle-end in alias.c.  TBAA code is used by both tree optimizers and RTL optimizers.

     Every language that wishes to perform language-specific alias analysis should define a function that computes, given a tree node, an alias set for the node.  Nodes in different alias sets are not allowed to alias.  For an example, see the C front-end function c_get_alias_set.

 4. Tree alias-oracle

     The tree alias-oracle provides means to disambiguate two memory references and memory references against statements.  The following queries are available:

       * refs_may_alias_p

       * ref_maybe_used_by_stmt_p

       * stmt_may_clobber_ref_p

     In addition to those two kind of statement walkers are available walking statements related to a reference ref. walk_non_aliased_vuses walks over dominating memory defining statements and calls back if the statement does not clobber ref providing the non-aliased VUSE.  The walk stops at the first clobbering statement or if asked to. walk_aliased_vdefs walks over dominating memory defining statements and calls back on each statement clobbering ref providing its aliasing VDEF.  The walk stops if asked to.

Memory model
============

The memory model used by the middle-end models that of the C/C++ languages.  The middle-end has the notion of an effective type of a memory region which is used for type-based alias analysis.

The following is a refinement of ISO C99 6.5/6, clarifying the block copy case to follow common sense and extending the concept of a dynamic effective type to objects with a declared type as required for C++.

     The effective type of an object for an access to its stored value is
     the declared type of the object or the effective type determined by
     a previous store to it.  If a value is stored into an object through
     an lvalue having a type that is not a character type, then the
     type of the lvalue becomes the effective type of the object for that
     access and for subsequent accesses that do not modify the stored value.
     If a value is copied into an object using memcpy or memmove,
     or is copied as an array of character type, then the effective type
     of the modified object for that access and for subsequent accesses that
     do not modify the value is undetermined.  For all other accesses to an
     object, the effective type of the object is simply the type of the
     lvalue used for the access.