GIMPLE
******

GIMPLE is a three-address representation derived from GENERIC by breaking down GENERIC expressions into tuples of no more than 3 operands (with some exceptions like function calls).  GIMPLE was heavily influenced by the SIMPLE IL used by the McCAT compiler project at McGill University, though we have made some different choices.  For one thing, SIMPLE doesn't support goto.

Temporaries are introduced to hold intermediate values needed to compute complex expressions. Additionally, all the control structures used in GENERIC are lowered into conditional jumps, lexical scopes are removed and exception regions are converted into an on the side exception region tree.

The compiler pass which converts GENERIC into GIMPLE is referred to as the gimplifier.  The gimplifier works recursively, generating GIMPLE tuples out of the original GENERIC expressions.

One of the early implementation strategies used for the GIMPLE representation was to use the same internal data structures used by front ends to represent parse trees. This simplified implementation because we could leverage existing functionality and interfaces. However, GIMPLE is a much more restrictive representation than abstract syntax trees (AST), therefore it does not require the full structural complexity provided by the main tree data structure.

The GENERIC representation of a function is stored in the DECL_SAVED_TREE field of the associated FUNCTION_DECL tree node.  It is converted to GIMPLE by a call to gimplify_function_tree.

If a front end wants to include language-specific tree codes in the tree representation which it provides to the back end, it must provide a definition of LANG_HOOKS_GIMPLIFY_EXPR which knows how to convert the front end trees to GIMPLE.  Usually such a hook will involve much of the same code for expanding front end trees to RTL.  This function can return fully lowered GIMPLE, or it can return GENERIC trees and let the main gimplifier lower them the rest of the way; this is often simpler. GIMPLE that is not fully lowered is known as ``High GIMPLE'' and consists of the IL before the pass pass_lower_cf.  High GIMPLE contains some container statements like lexical scopes (represented by GIMPLE_BIND) and nested expressions (e.g., GIMPLE_TRY), while ``Low GIMPLE'' exposes all of the implicit jumps for control and exception expressions directly in the IL and EH region trees.

The C and C++ front ends currently convert directly from front end trees to GIMPLE, and hand that off to the back end rather than first converting to GENERIC.  Their gimplifier hooks know about all the _STMT nodes and how to convert them to GENERIC forms.  There was some work done on a genericization pass which would run first, but the existence of STMT_EXPR meant that in order to convert all of the C statements into GENERIC equivalents would involve walking the entire tree anyway, so it was simpler to lower all the way.  This might change in the future if someone writes an optimization pass which would work better with higher-level trees, but currently the optimizers all expect GIMPLE.

You can request to dump a C-like representation of the GIMPLE form with the flag -fdump-tree-gimple.

Tuple representation
====================

GIMPLE instructions are tuples of variable size divided in two groups: a header describing the instruction and its locations, and a variable length body with all the operands. Tuples are organized into a hierarchy with 3 main classes of tuples.

gimple_statement_base (gsbase)
------------------------------

This is the root of the hierarchy, it holds basic information needed by most GIMPLE statements. There are some fields that may not be relevant to every GIMPLE statement, but those were moved into the base structure to take advantage of holes left by other fields (thus making the structure more compact).  The structure takes 4 words (32 bytes) on 64 bit hosts:

Field				  Size (bits)
code			  8
subcode			  16
no_warning			  1
visited			  1
nontemporal_move		  1
plf			  2
modified			  1
has_volatile_ops		  1
references_memory_p	  1
uid			  32
location			  32
num_ops			  32
bb				  64
block			  63
Total size			  32 bytes

  * code Main identifier for a GIMPLE instruction.

  * subcode Used to distinguish different variants of the same basic instruction or provide flags applicable to a given code. The subcode flags field has different uses depending on the code of the instruction, but mostly it distinguishes instructions of the same family. The most prominent use of this field is in assignments, where subcode indicates the operation done on the RHS of the assignment. For example, a = b + c is encoded as GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>.

  * no_warning Bitflag to indicate whether a warning has already been issued on this statement.

  * visited General purpose ``visited'' marker. Set and cleared by each pass when needed.

  * nontemporal_move Bitflag used in assignments that represent non-temporal moves. Although this bitflag is only used in assignments, it was moved into the base to take advantage of the bit holes left by the previous fields.

  * plf Pass Local Flags. This 2-bit mask can be used as general purpose markers by any pass. Passes are responsible for clearing and setting these two flags accordingly.

  * modified Bitflag to indicate whether the statement has been modified. Used mainly by the operand scanner to determine when to re-scan a statement for operands.

  * has_volatile_ops Bitflag to indicate whether this statement contains operands that have been marked volatile.

  * references_memory_p Bitflag to indicate whether this statement contains memory references (i.e., its operands are either global variables, or pointer dereferences or anything that must reside in memory).

  * uid This is an unsigned integer used by passes that want to assign IDs to every statement. These IDs must be assigned and used by each pass.

  * location This is a location_t identifier to specify source code location for this statement. It is inherited from the front end.

  * num_ops Number of operands that this statement has. This specifies the size of the operand vector embedded in the tuple. Only used in some tuples, but it is declared in the base tuple to take advantage of the 32-bit hole left by the previous fields.

  * bb Basic block holding the instruction.

  * block Lexical block holding this statement.  Also used for debug information generation.

gimple_statement_with_ops
-------------------------

This tuple is actually split in two: gimple_statement_with_ops_base and gimple_statement_with_ops. This is needed to accommodate the way the operand vector is allocated. The operand vector is defined to be an array of 1 element. So, to allocate a dynamic number of operands, the memory allocator (gimple_alloc) simply allocates enough memory to hold the structure itself plus N - 1 operands which run ``off the end'' of the structure. For example, to allocate space for a tuple with 3 operands, gimple_alloc reserves sizeof (struct gimple_statement_with_ops) + 2 * sizeof (tree) bytes.

On the other hand, several fields in this tuple need to be shared with the gimple_statement_with_memory_ops tuple. So, these common fields are placed in gimple_statement_with_ops_base which is then inherited from the other two tuples.

gsbase		  256
def_ops		  64
use_ops		  64
op		  num_ops * 64
Total size		  48 + 8 * num_ops bytes

  * gsbase Inherited from struct gimple_statement_base.

  * def_ops Array of pointers into the operand array indicating all the slots that contain a variable written-to by the statement. This array is also used for immediate use chaining. Note that it would be possible to not rely on this array, but the changes required to implement this are pretty invasive.

  * use_ops Similar to def_ops but for variables read by the statement.

  * op Array of trees with num_ops slots.

gimple_statement_with_memory_ops
--------------------------------

This tuple is essentially identical to gimple_statement_with_ops, except that it contains 4 additional fields to hold vectors related memory stores and loads.  Similar to the previous case, the structure is split in two to accommodate for the operand vector (gimple_statement_with_memory_ops_base and gimple_statement_with_memory_ops).

Field			  Size (bits)
gsbase		  256
def_ops		  64
use_ops		  64
vdef_ops		  64
vuse_ops		  64
stores		  64
loads		  64
op			  num_ops * 64
Total size		  80 + 8 * num_ops bytes

  * vdef_ops Similar to def_ops but for VDEF operators. There is one entry per memory symbol written by this statement. This is used to maintain the memory SSA use-def and def-def chains.

  * vuse_ops Similar to use_ops but for VUSE operators. There is one entry per memory symbol loaded by this statement. This is used to maintain the memory SSA use-def chains.

  * stores Bitset with all the UIDs for the symbols written-to by the statement.  This is different than vdef_ops in that all the affected symbols are mentioned in this set.  If memory partitioning is enabled, the vdef_ops vector will refer to memory partitions. Furthermore, no SSA information is stored in this set.

  * loads Similar to stores, but for memory loads. (Note that there is some amount of redundancy here, it should be possible to reduce memory utilization further by removing these sets).

All the other tuples are defined in terms of these three basic ones. Each tuple will add some fields. The main gimple type is defined to be the union of all these structures (GTY markers elided for clarity):

     union gimple_statement_d
     {
       struct gimple_statement_base gsbase;
       struct gimple_statement_with_ops gsops;
       struct gimple_statement_with_memory_ops gsmem;
       struct gimple_statement_omp omp;
       struct gimple_statement_bind gimple_bind;
       struct gimple_statement_catch gimple_catch;
       struct gimple_statement_eh_filter gimple_eh_filter;
       struct gimple_statement_phi gimple_phi;
       struct gimple_statement_resx gimple_resx;
       struct gimple_statement_try gimple_try;
       struct gimple_statement_wce gimple_wce;
       struct gimple_statement_asm gimple_asm;
       struct gimple_statement_omp_critical gimple_omp_critical;
       struct gimple_statement_omp_for gimple_omp_for;
       struct gimple_statement_omp_parallel gimple_omp_parallel;
       struct gimple_statement_omp_task gimple_omp_task;
       struct gimple_statement_omp_sections gimple_omp_sections;
       struct gimple_statement_omp_single gimple_omp_single;
       struct gimple_statement_omp_continue gimple_omp_continue;
       struct gimple_statement_omp_atomic_load gimple_omp_atomic_load;
       struct gimple_statement_omp_atomic_store gimple_omp_atomic_store;
     };

GIMPLE instruction set
======================

The following table briefly describes the GIMPLE instruction set.

Instruction			  High GIMPLE	  Low GIMPLE
GIMPLE_ASM			  x			  x
GIMPLE_ASSIGN		  x			  x
GIMPLE_BIND		  x
GIMPLE_CALL		  x			  x
GIMPLE_CATCH		  x
GIMPLE_COND		  x			  x
GIMPLE_DEBUG		  x			  x
GIMPLE_EH_FILTER		  x
GIMPLE_GOTO		  x			  x
GIMPLE_LABEL		  x			  x
GIMPLE_NOP			  x			  x
GIMPLE_OMP_ATOMIC_LOAD	  x			  x
GIMPLE_OMP_ATOMIC_STORE	  x			  x
GIMPLE_OMP_CONTINUE	  x			  x
GIMPLE_OMP_CRITICAL	  x			  x
GIMPLE_OMP_FOR		  x			  x
GIMPLE_OMP_MASTER		  x			  x
GIMPLE_OMP_ORDERED		  x			  x
GIMPLE_OMP_PARALLEL	  x			  x
GIMPLE_OMP_RETURN		  x			  x
GIMPLE_OMP_SECTION		  x			  x
GIMPLE_OMP_SECTIONS	  x			  x
GIMPLE_OMP_SECTIONS_SWITCH	  x			  x
GIMPLE_OMP_SINGLE		  x			  x
GIMPLE_PHI			  			  x
GIMPLE_RESX		  			  x
GIMPLE_RETURN		  x			  x
GIMPLE_SWITCH		  x			  x
GIMPLE_TRY			  x

Exception Handling
==================

Other exception handling constructs are represented using GIMPLE_TRY_CATCH.  GIMPLE_TRY_CATCH has two operands.  The first operand is a sequence of statements to execute.  If executing these statements does not throw an exception, then the second operand is ignored.  Otherwise, if an exception is thrown, then the second operand of the GIMPLE_TRY_CATCH is checked.  The second operand may have the following forms:

 1. A sequence of statements to execute.  When an exception occurs, these statements are executed, and then the exception is rethrown.

 2. A sequence of GIMPLE_CATCH statements.  Each GIMPLE_CATCH has a list of applicable exception types and handler code.  If the thrown exception matches one of the caught types, the associated handler code is executed.  If the handler code falls off the bottom, execution continues after the original GIMPLE_TRY_CATCH.

 3. A GIMPLE_EH_FILTER statement.  This has a list of permitted exception types, and code to handle a match failure.  If the thrown exception does not match one of the allowed types, the associated match failure code is executed.  If the thrown exception does match, it continues unwinding the stack looking for the next handler.

Currently throwing an exception is not directly represented in GIMPLE, since it is implemented by calling a function.  At some point in the future we will want to add some way to express that the call will throw an exception of a known type.

Just before running the optimizers, the compiler lowers the high-level EH constructs above into a set of gotos, magic labels, and EH regions.  Continuing to unwind at the end of a cleanup is represented with a GIMPLE_RESX.

Temporaries
===========

When gimplification encounters a subexpression that is too complex, it creates a new temporary variable to hold the value of the subexpression, and adds a new statement to initialize it before the current statement. These special temporaries are known as expression temporaries, and are allocated using get_formal_tmp_var.  The compiler tries to always evaluate identical expressions into the same temporary, to simplify elimination of redundant calculations.

We can only use expression temporaries when we know that it will not be reevaluated before its value is used, and that it will not be otherwise modified (These restrictions are derived from those in Morgan 4.8.). Other temporaries can be allocated using get_initialized_tmp_var or create_tmp_var.

Currently, an expression like a = b + 5 is not reduced any further.  We tried converting it to something like

     T1 = b + 5;
     a = T1;

but this bloated the representation for minimal benefit.  However, a variable which must live in memory cannot appear in an expression; its value is explicitly loaded into a temporary first.  Similarly, storing the value of an expression to a memory variable goes through a temporary.

Operands
========

In general, expressions in GIMPLE consist of an operation and the appropriate number of simple operands; these operands must either be a GIMPLE rvalue (is_gimple_val), i.e. a constant or a register variable.  More complex operands are factored out into temporaries, so that

     a = b + c + d

becomes

     T1 = b + c;
     a = T1 + d;

The same rule holds for arguments to a GIMPLE_CALL.

The target of an assignment is usually a variable, but can also be a MEM_REF or a compound lvalue as described below.

Compound Expressions
--------------------

The left-hand side of a C comma expression is simply moved into a separate statement.

Compound Lvalues
----------------

Currently compound lvalues involving array and structure field references are not broken down; an expression like a.b[2] = 42 is not reduced any further (though complex array subscripts are).  This restriction is a workaround for limitations in later optimizers; if we were to convert this to

     T1 = &a.b;
     T1[2] = 42;

alias analysis would not remember that the reference to T1[2] came by way of a.b, so it would think that the assignment could alias another member of a; this broke struct-alias-1.c.  Future optimizer improvements may make this limitation unnecessary.

Conditional Expressions
-----------------------

A C ?: expression is converted into an if statement with each branch assigning to the same temporary.  So,

     a = b ? c : d;

becomes

     if (b == 1)
       T1 = c;
     else
       T1 = d;
     a = T1;

The GIMPLE level if-conversion pass re-introduces ?: expression, if appropriate. It is used to vectorize loops with conditions using vector conditional operations.

Note that in GIMPLE, if statements are represented using GIMPLE_COND, as described below.

Logical Operators
-----------------

Except when they appear in the condition operand of a GIMPLE_COND, logical `and' and `or' operators are simplified as follows: a = b && c becomes

     T1 = (bool)b;
     if (T1 == true)
       T1 = (bool)c;
     a = T1;

Note that T1 in this example cannot be an expression temporary, because it has two different assignments.

Manipulating operands
---------------------

All gimple operands are of type tree.  But only certain types of trees are allowed to be used as operand tuples.  Basic validation is controlled by the function get_gimple_rhs_class, which given a tree code, returns an enum with the following values of type enum gimple_rhs_class

  * GIMPLE_INVALID_RHS The tree cannot be used as a GIMPLE operand.

  * GIMPLE_TERNARY_RHS The tree is a valid GIMPLE ternary operation.

  * GIMPLE_BINARY_RHS The tree is a valid GIMPLE binary operation.

  * GIMPLE_UNARY_RHS The tree is a valid GIMPLE unary operation.

  * GIMPLE_SINGLE_RHS The tree is a single object, that cannot be split into simpler operands (for instance, SSA_NAME, VAR_DECL, COMPONENT_REF, etc).

     This operand class also acts as an escape hatch for tree nodes that may be flattened out into the operand vector, but would need more than two slots on the RHS.  For instance, a COND_EXPR expression of the form (a op b) ? x : y could be flattened out on the operand vector using 4 slots, but it would also require additional processing to distinguish c = a op b from c = a op b ? x : y.  Something similar occurs with ASSERT_EXPR.   In time, these special case tree expressions should be flattened into the operand vector.

For tree nodes in the categories GIMPLE_TERNARY_RHS, GIMPLE_BINARY_RHS and GIMPLE_UNARY_RHS, they cannot be stored inside tuples directly.  They first need to be flattened and separated into individual components.  For instance, given the GENERIC expression

     a = b + c

its tree representation is:

     MODIFY_EXPR <VAR_DECL  <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>

In this case, the GIMPLE form for this statement is logically identical to its GENERIC form but in GIMPLE, the PLUS_EXPR on the RHS of the assignment is not represented as a tree, instead the two operands are taken out of the PLUS_EXPR sub-tree and flattened into the GIMPLE tuple as follows:

     GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>

Operand vector allocation
-------------------------

The operand vector is stored at the bottom of the three tuple structures that accept operands. This means, that depending on the code of a given statement, its operand vector will be at different offsets from the base of the structure.  To access tuple operands use the following accessors

 -- GIMPLE function: unsigned gimple_num_ops (gimple g)
     Returns the number of operands in statement G.

 -- GIMPLE function: tree gimple_op (gimple g, unsigned i)
     Returns operand I from statement G.

 -- GIMPLE function: tree * gimple_ops (gimple g)
     Returns a pointer into the operand vector for statement G.  This is computed using an internal table called gimple_ops_offset_[]. This table is indexed by the gimple code of G.

     When the compiler is built, this table is filled-in using the sizes of the structures used by each statement code defined in gimple.def.  Since the operand vector is at the bottom of the structure, for a gimple code C the offset is computed as sizeof (struct-of C) - sizeof (tree).

     This mechanism adds one memory indirection to every access when using gimple_op(), if this becomes a bottleneck, a pass can choose to memoize the result from gimple_ops() and use that to access the operands.

Operand validation
------------------

When adding a new operand to a gimple statement, the operand will be validated according to what each tuple accepts in its operand vector.  These predicates are called by the gimple_NAME_set_...().  Each tuple will use one of the following predicates (Note, this list is not exhaustive):

 -- GIMPLE function: bool is_gimple_val (tree t)
     Returns true if t is a "GIMPLE value", which are all the non-addressable stack variables (variables for which is_gimple_reg returns true) and constants (expressions for which is_gimple_min_invariant returns true).

 -- GIMPLE function: bool is_gimple_addressable (tree t)
     Returns true if t is a symbol or memory reference whose address can be taken.

 -- GIMPLE function: bool is_gimple_asm_val (tree t)
     Similar to is_gimple_val but it also accepts hard registers.

 -- GIMPLE function: bool is_gimple_call_addr (tree t)
     Return true if t is a valid expression to use as the function called by a GIMPLE_CALL.

 -- GIMPLE function: bool is_gimple_mem_ref_addr (tree t)
     Return true if t is a valid expression to use as first operand of a MEM_REF expression.

 -- GIMPLE function: bool is_gimple_constant (tree t)
     Return true if t is a valid gimple constant.

 -- GIMPLE function: bool is_gimple_min_invariant (tree t)
     Return true if t is a valid minimal invariant.  This is different from constants, in that the specific value of t may not be known at compile time, but it is known that it doesn't change (e.g., the address of a function local variable).

 -- GIMPLE function: bool is_gimple_ip_invariant (tree t)
     Return true if t is an interprocedural invariant.  This means that t is a valid invariant in all functions (e.g. it can be an address of a global variable but not of a local one).

 -- GIMPLE function: bool is_gimple_ip_invariant_address (tree t)
     Return true if t is an ADDR_EXPR that does not change once the program is running (and which is valid in all functions).

Statement validation
--------------------

 -- GIMPLE function: bool is_gimple_assign (gimple g)
     Return true if the code of g is GIMPLE_ASSIGN.

 -- GIMPLE function: bool is_gimple_call (gimple g)
     Return true if the code of g is GIMPLE_CALL.

 -- GIMPLE function: bool is_gimple_debug (gimple g)
     Return true if the code of g is GIMPLE_DEBUG.

 -- GIMPLE function: bool gimple_assign_cast_p (gimple g)
     Return true if g is a GIMPLE_ASSIGN that performs a type cast operation.

 -- GIMPLE function: bool gimple_debug_bind_p (gimple g)
     Return true if g is a GIMPLE_DEBUG that binds the value of an expression to a variable.

 -- GIMPLE function: bool is_gimple_omp (gimple g)
     Return true if g is any of the OpenMP codes.

Manipulating GIMPLE statements
==============================

This section documents all the functions available to handle each of the GIMPLE instructions.

Common accessors
----------------

The following are common accessors for gimple statements.

 -- GIMPLE function: enum gimple_code gimple_code (gimple g)
     Return the code for statement G.

 -- GIMPLE function: basic_block gimple_bb (gimple g)
     Return the basic block to which statement G belongs to.

 -- GIMPLE function: tree gimple_block (gimple g)
     Return the lexical scope block holding statement G.

 -- GIMPLE function: tree gimple_expr_type (gimple stmt)
     Return the type of the main expression computed by STMT. Return void_type_node if STMT computes nothing. This will only return something meaningful for GIMPLE_ASSIGN, GIMPLE_COND and GIMPLE_CALL.  For all other tuple codes, it will return void_type_node.

 -- GIMPLE function: enum tree_code gimple_expr_code (gimple stmt)
     Return the tree code for the expression computed by STMT.  This is only meaningful for GIMPLE_CALL, GIMPLE_ASSIGN and GIMPLE_COND.  If STMT is GIMPLE_CALL, it will return CALL_EXPR. For GIMPLE_COND, it returns the code of the comparison predicate. For GIMPLE_ASSIGN it returns the code of the operation performed by the RHS of the assignment.

 -- GIMPLE function: void gimple_set_block (gimple g, tree block)
     Set the lexical scope block of G to BLOCK.

 -- GIMPLE function: location_t gimple_locus (gimple g)
     Return locus information for statement G.

 -- GIMPLE function: void gimple_set_locus (gimple g, location_t locus)
     Set locus information for statement G.

 -- GIMPLE function: bool gimple_locus_empty_p (gimple g)
     Return true if G does not have locus information.

 -- GIMPLE function: bool gimple_no_warning_p (gimple stmt)
     Return true if no warnings should be emitted for statement STMT.

 -- GIMPLE function: void gimple_set_visited (gimple stmt, bool visited_p)
     Set the visited status on statement STMT to VISITED_P.

 -- GIMPLE function: bool gimple_visited_p (gimple stmt)
     Return the visited status on statement STMT.

 -- GIMPLE function: void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
     Set pass local flag PLF on statement STMT to VAL_P.

 -- GIMPLE function: unsigned int gimple_plf (gimple stmt, enum plf_mask plf)
     Return the value of pass local flag PLF on statement STMT.

 -- GIMPLE function: bool gimple_has_ops (gimple g)
     Return true if statement G has register or memory operands.

 -- GIMPLE function: bool gimple_has_mem_ops (gimple g)
     Return true if statement G has memory operands.

 -- GIMPLE function: unsigned gimple_num_ops (gimple g)
     Return the number of operands for statement G.

 -- GIMPLE function: tree * gimple_ops (gimple g)
     Return the array of operands for statement G.

 -- GIMPLE function: tree gimple_op (gimple g, unsigned i)
     Return operand I for statement G.

 -- GIMPLE function: tree * gimple_op_ptr (gimple g, unsigned i)
     Return a pointer to operand I for statement G.

 -- GIMPLE function: void gimple_set_op (gimple g, unsigned i, tree op)
     Set operand I of statement G to OP.

 -- GIMPLE function: bitmap gimple_addresses_taken (gimple stmt)
     Return the set of symbols that have had their address taken by STMT.

 -- GIMPLE function: struct def_optype_d * gimple_def_ops (gimple g)
     Return the set of DEF operands for statement G.

 -- GIMPLE function: void gimple_set_def_ops (gimple g, struct def_optype_d *def)
     Set DEF to be the set of DEF operands for statement G.

 -- GIMPLE function: struct use_optype_d * gimple_use_ops (gimple g)
     Return the set of USE operands for statement G.

 -- GIMPLE function: void gimple_set_use_ops (gimple g, struct use_optype_d *use)
     Set USE to be the set of USE operands for statement G.

 -- GIMPLE function: struct voptype_d * gimple_vuse_ops (gimple g)
     Return the set of VUSE operands for statement G.

 -- GIMPLE function: void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
     Set OPS to be the set of VUSE operands for statement G.

 -- GIMPLE function: struct voptype_d * gimple_vdef_ops (gimple g)
     Return the set of VDEF operands for statement G.

 -- GIMPLE function: void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
     Set OPS to be the set of VDEF operands for statement G.

 -- GIMPLE function: bitmap gimple_loaded_syms (gimple g)
     Return the set of symbols loaded by statement G.  Each element of the set is the DECL_UID of the corresponding symbol.

 -- GIMPLE function: bitmap gimple_stored_syms (gimple g)
     Return the set of symbols stored by statement G.  Each element of the set is the DECL_UID of the corresponding symbol.

 -- GIMPLE function: bool gimple_modified_p (gimple g)
     Return true if statement G has operands and the modified field has been set.

 -- GIMPLE function: bool gimple_has_volatile_ops (gimple stmt)
     Return true if statement STMT contains volatile operands.

 -- GIMPLE function: void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
     Return true if statement STMT contains volatile operands.

 -- GIMPLE function: void update_stmt (gimple s)
     Mark statement S as modified, and update it.

 -- GIMPLE function: void update_stmt_if_modified (gimple s)
     Update statement S if it has been marked modified.

 -- GIMPLE function: gimple gimple_copy (gimple stmt)
     Return a deep copy of statement STMT.

Tuple specific accessors
========================

GIMPLE_ASM
----------

 -- GIMPLE function: gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
     Build a GIMPLE_ASM statement.  This statement is used for building in-line assembly constructs.  STRING is the assembly code.  NINPUT is the number of register inputs.  NOUTPUT is the number of register outputs.  NCLOBBERS is the number of clobbered registers.  The rest of the arguments trees for each input, output, and clobbered registers.

 -- GIMPLE function: gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
     Identical to gimple_build_asm, but the arguments are passed in VECs.

 -- GIMPLE function: unsigned gimple_asm_ninputs (gimple g)
     Return the number of input operands for GIMPLE_ASM G.

 -- GIMPLE function: unsigned gimple_asm_noutputs (gimple g)
     Return the number of output operands for GIMPLE_ASM G.

 -- GIMPLE function: unsigned gimple_asm_nclobbers (gimple g)
     Return the number of clobber operands for GIMPLE_ASM G.

 -- GIMPLE function: tree gimple_asm_input_op (gimple g, unsigned index)
     Return input operand INDEX of GIMPLE_ASM G.

 -- GIMPLE function: void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
     Set IN_OP to be input operand INDEX in GIMPLE_ASM G.

 -- GIMPLE function: tree gimple_asm_output_op (gimple g, unsigned index)
     Return output operand INDEX of GIMPLE_ASM G.

 -- GIMPLE function: void gimple_asm_set_output_op (gimple g,
     unsigned index, tree out_op)
     Set OUT_OP to be output operand INDEX in GIMPLE_ASM G.

 -- GIMPLE function: tree gimple_asm_clobber_op (gimple g, unsigned index)
     Return clobber operand INDEX of GIMPLE_ASM G.

 -- GIMPLE function: void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
     Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM G.

 -- GIMPLE function: const char * gimple_asm_string (gimple g)
     Return the string representing the assembly instruction in GIMPLE_ASM G.

 -- GIMPLE function: bool gimple_asm_volatile_p (gimple g)
     Return true if G is an asm statement marked volatile.

 -- GIMPLE function: void gimple_asm_set_volatile (gimple g)
     Mark asm statement G as volatile.

 -- GIMPLE function: void gimple_asm_clear_volatile (gimple g)
     Remove volatile marker from asm statement G.

GIMPLE_ASSIGN
-------------

 -- GIMPLE function: gimple gimple_build_assign (tree lhs, tree rhs)
     Build a GIMPLE_ASSIGN statement.  The left-hand side is an lvalue passed in lhs.  The right-hand side can be either a unary or binary tree expression.  The expression tree rhs will be flattened and its operands assigned to the corresponding operand slots in the new statement.  This function is useful when you already have a tree expression that you want to convert into a tuple.  However, try to avoid building expression trees for the sole purpose of calling this function.  If you already have the operands in separate trees, it is better to use gimple_build_assign_with_ops.

 -- GIMPLE function: gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
     Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.

DST/SRC are the destination and source respectively.  You can pass ungimplified trees in DST or SRC, in which case they will be converted to a gimple operand if necessary.

This function returns the newly created GIMPLE_ASSIGN tuple.

 -- GIMPLE function: gimple gimple_build_assign_with_ops
     (enum tree_code subcode, tree lhs, tree op1, tree op2)
     This function is similar to gimple_build_assign, but is used to build a GIMPLE_ASSIGN statement when the operands of the right-hand side of the assignment are already split into different operands.

     The left-hand side is an lvalue passed in lhs.  Subcode is the tree_code for the right-hand side of the assignment.  Op1 and op2 are the operands.  If op2 is null, subcode must be a tree_code for a unary expression.

 -- GIMPLE function: enum tree_code gimple_assign_rhs_code (gimple g)
     Return the code of the expression computed on the RHS of assignment statement G.

 -- GIMPLE function: enum gimple_rhs_class gimple_assign_rhs_class (gimple g)
     Return the gimple rhs class of the code for the expression computed on the rhs of assignment statement G.  This will never return GIMPLE_INVALID_RHS.

 -- GIMPLE function: tree gimple_assign_lhs (gimple g)
     Return the LHS of assignment statement G.

 -- GIMPLE function: tree * gimple_assign_lhs_ptr (gimple g)
     Return a pointer to the LHS of assignment statement G.

 -- GIMPLE function: tree gimple_assign_rhs1 (gimple g)
     Return the first operand on the RHS of assignment statement G.

 -- GIMPLE function: tree * gimple_assign_rhs1_ptr (gimple g)
     Return the address of the first operand on the RHS of assignment statement G.

 -- GIMPLE function: tree gimple_assign_rhs2 (gimple g)
     Return the second operand on the RHS of assignment statement G.

 -- GIMPLE function: tree * gimple_assign_rhs2_ptr (gimple g)
     Return the address of the second operand on the RHS of assignment statement G.

 -- GIMPLE function: tree gimple_assign_rhs3 (gimple g)
     Return the third operand on the RHS of assignment statement G.

 -- GIMPLE function: tree * gimple_assign_rhs3_ptr (gimple g)
     Return the address of the third operand on the RHS of assignment statement G.

 -- GIMPLE function: void gimple_assign_set_lhs (gimple g, tree lhs)
     Set LHS to be the LHS operand of assignment statement G.

 -- GIMPLE function: void gimple_assign_set_rhs1 (gimple g, tree rhs)
     Set RHS to be the first operand on the RHS of assignment statement G.

 -- GIMPLE function: void gimple_assign_set_rhs2 (gimple g, tree rhs)
     Set RHS to be the second operand on the RHS of assignment statement G.

 -- GIMPLE function: void gimple_assign_set_rhs3 (gimple g, tree rhs)
     Set RHS to be the third operand on the RHS of assignment statement G.

 -- GIMPLE function: bool gimple_assign_cast_p (gimple s)
     Return true if S is a type-cast assignment.

GIMPLE_BIND
-----------

 -- GIMPLE function: gimple gimple_build_bind (tree vars, gimple_seq body)
     Build a GIMPLE_BIND statement with a list of variables in VARS and a body of statements in sequence BODY.

 -- GIMPLE function: tree gimple_bind_vars (gimple g)
     Return the variables declared in the GIMPLE_BIND statement G.

 -- GIMPLE function: void gimple_bind_set_vars (gimple g, tree vars)
     Set VARS to be the set of variables declared in the GIMPLE_BIND statement G.

 -- GIMPLE function: void gimple_bind_append_vars (gimple g, tree vars)
     Append VARS to the set of variables declared in the GIMPLE_BIND statement G.

 -- GIMPLE function: gimple_seq gimple_bind_body (gimple g)
     Return the GIMPLE sequence contained in the GIMPLE_BIND statement G.

 -- GIMPLE function: void gimple_bind_set_body (gimple g, gimple_seq seq)
     Set SEQ to be sequence contained in the GIMPLE_BIND statement G.

 -- GIMPLE function: void gimple_bind_add_stmt (gimple gs, gimple stmt)
     Append a statement to the end of a GIMPLE_BIND's body.

 -- GIMPLE function: void gimple_bind_add_seq (gimple gs, gimple_seq seq)
     Append a sequence of statements to the end of a GIMPLE_BIND's body.

 -- GIMPLE function: tree gimple_bind_block (gimple g)
     Return the TREE_BLOCK node associated with GIMPLE_BIND statement G. This is analogous to the BIND_EXPR_BLOCK field in trees.

 -- GIMPLE function: void gimple_bind_set_block (gimple g, tree block)
     Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND statement G.

GIMPLE_CALL
-----------

 -- GIMPLE function: gimple gimple_build_call (tree fn, unsigned nargs, ...)
     Build a GIMPLE_CALL statement to function FN.  The argument FN must be either a FUNCTION_DECL or a gimple call address as determined by is_gimple_call_addr.  NARGS are the number of arguments.  The rest of the arguments follow the argument NARGS, and must be trees that are valid as rvalues in gimple (i.e., each operand is validated with is_gimple_operand).

 -- GIMPLE function: gimple gimple_build_call_from_tree (tree call_expr)
     Build a GIMPLE_CALL from a CALL_EXPR node.  The arguments and the function are taken from the expression directly.  This routine assumes that call_expr is already in GIMPLE form.  That is, its operands are GIMPLE values and the function call needs no further simplification.  All the call flags in call_expr are copied over to the new GIMPLE_CALL.

 -- GIMPLE function: gimple gimple_build_call_vec (tree fn, VEC(tree, heap) *args)
     Identical to gimple_build_call but the arguments are stored in a VEC().

 -- GIMPLE function: tree gimple_call_lhs (gimple g)
     Return the LHS of call statement G.

 -- GIMPLE function: tree * gimple_call_lhs_ptr (gimple g)
     Return a pointer to the LHS of call statement G.

 -- GIMPLE function: void gimple_call_set_lhs (gimple g, tree lhs)
     Set LHS to be the LHS operand of call statement G.

 -- GIMPLE function: tree gimple_call_fn (gimple g)
     Return the tree node representing the function called by call statement G.

 -- GIMPLE function: void gimple_call_set_fn (gimple g, tree fn)
     Set FN to be the function called by call statement G.  This has to be a gimple value specifying the address of the called function.

 -- GIMPLE function: tree gimple_call_fndecl (gimple g)
     If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it. Otherwise return NULL.  This function is analogous to get_callee_fndecl in GENERIC.

 -- GIMPLE function: tree gimple_call_set_fndecl (gimple g, tree fndecl)
     Set the called function to FNDECL.

 -- GIMPLE function: tree gimple_call_return_type (gimple g)
     Return the type returned by call statement G.

 -- GIMPLE function: tree gimple_call_chain (gimple g)
     Return the static chain for call statement G.

 -- GIMPLE function: void gimple_call_set_chain (gimple g, tree chain)
     Set CHAIN to be the static chain for call statement G.

 -- GIMPLE function: unsigned gimple_call_num_args (gimple g)
     Return the number of arguments used by call statement G.

 -- GIMPLE function: tree gimple_call_arg (gimple g, unsigned index)
     Return the argument at position INDEX for call statement G.  The first argument is 0.

 -- GIMPLE function: tree * gimple_call_arg_ptr (gimple g, unsigned index)
     Return a pointer to the argument at position INDEX for call statement G.

 -- GIMPLE function: void gimple_call_set_arg (gimple g, unsigned index, tree arg)
     Set ARG to be the argument at position INDEX for call statement G.

 -- GIMPLE function: void gimple_call_set_tail (gimple s)
     Mark call statement S as being a tail call (i.e., a call just before the exit of a function). These calls are candidate for tail call optimization.

 -- GIMPLE function: bool gimple_call_tail_p (gimple s)
     Return true if GIMPLE_CALL S is marked as a tail call.

 -- GIMPLE function: void gimple_call_mark_uninlinable (gimple s)
     Mark GIMPLE_CALL S as being uninlinable.

 -- GIMPLE function: bool gimple_call_cannot_inline_p (gimple s)
     Return true if GIMPLE_CALL S cannot be inlined.

 -- GIMPLE function: bool gimple_call_noreturn_p (gimple s)
     Return true if S is a noreturn call.

 -- GIMPLE function: gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
     Build a GIMPLE_CALL identical to STMT but skipping the arguments in the positions marked by the set ARGS_TO_SKIP.

GIMPLE_CATCH
------------

 -- GIMPLE function: gimple gimple_build_catch (tree types, gimple_seq handler)
     Build a GIMPLE_CATCH statement.  TYPES are the tree types this catch handles.  HANDLER is a sequence of statements with the code for the handler.

 -- GIMPLE function: tree gimple_catch_types (gimple g)
     Return the types handled by GIMPLE_CATCH statement G.

 -- GIMPLE function: tree * gimple_catch_types_ptr (gimple g)
     Return a pointer to the types handled by GIMPLE_CATCH statement G.

 -- GIMPLE function: gimple_seq gimple_catch_handler (gimple g)
     Return the GIMPLE sequence representing the body of the handler of GIMPLE_CATCH statement G.

 -- GIMPLE function: void gimple_catch_set_types (gimple g, tree t)
     Set T to be the set of types handled by GIMPLE_CATCH G.

 -- GIMPLE function: void gimple_catch_set_handler (gimple g, gimple_seq handler)
     Set HANDLER to be the body of GIMPLE_CATCH G.

GIMPLE_COND
-----------

 -- GIMPLE function: gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
     Build a GIMPLE_COND statement.  A GIMPLE_COND statement compares LHS and RHS and if the condition in PRED_CODE is true, jump to the label in t_label, otherwise jump to the label in f_label. PRED_CODE are relational operator tree codes like EQ_EXPR, LT_EXPR, LE_EXPR, NE_EXPR, etc.

 -- GIMPLE function: gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
     Build a GIMPLE_COND statement from the conditional expression tree COND.  T_LABEL and F_LABEL are as in gimple_build_cond.

 -- GIMPLE function: enum tree_code gimple_cond_code (gimple g)
     Return the code of the predicate computed by conditional statement G.

 -- GIMPLE function: void gimple_cond_set_code (gimple g, enum tree_code code)
     Set CODE to be the predicate code for the conditional statement G.

 -- GIMPLE function: tree gimple_cond_lhs (gimple g)
     Return the LHS of the predicate computed by conditional statement G.

 -- GIMPLE function: void gimple_cond_set_lhs (gimple g, tree lhs)
     Set LHS to be the LHS operand of the predicate computed by conditional statement G.

 -- GIMPLE function: tree gimple_cond_rhs (gimple g)
     Return the RHS operand of the predicate computed by conditional G.

 -- GIMPLE function: void gimple_cond_set_rhs (gimple g, tree rhs)
     Set RHS to be the RHS operand of the predicate computed by conditional statement G.

 -- GIMPLE function: tree gimple_cond_true_label (gimple g)
     Return the label used by conditional statement G when its predicate evaluates to true.

 -- GIMPLE function: void gimple_cond_set_true_label (gimple g, tree label)
     Set LABEL to be the label used by conditional statement G when its predicate evaluates to true.

 -- GIMPLE function: void gimple_cond_set_false_label (gimple g, tree label)
     Set LABEL to be the label used by conditional statement G when its predicate evaluates to false.

 -- GIMPLE function: tree gimple_cond_false_label (gimple g)
     Return the label used by conditional statement G when its predicate evaluates to false.

 -- GIMPLE function: void gimple_cond_make_false (gimple g)
     Set the conditional COND_STMT to be of the form 'if (1 == 0)'.

 -- GIMPLE function: void gimple_cond_make_true (gimple g)
     Set the conditional COND_STMT to be of the form 'if (1 == 1)'.

GIMPLE_DEBUG
------------

 -- GIMPLE function: gimple gimple_build_debug_bind (tree var, tree value, gimple stmt)
     Build a GIMPLE_DEBUG statement with GIMPLE_DEBUG_BIND of subcode.  The effect of this statement is to tell debug information generation machinery that the value of user variable var is given by value at that point, and to remain with that value until var runs out of scope, a dynamically-subsequent debug bind statement overrides the binding, or conflicting values reach a control flow merge point.  Even if components of the value expression change afterwards, the variable is supposed to retain the same value, though not necessarily the same location.

     It is expected that var be most often a tree for automatic user variables (VAR_DECL or PARM_DECL) that satisfy the requirements for gimple registers, but it may also be a tree for a scalarized component of a user variable (ARRAY_REF, COMPONENT_REF), or a debug temporary (DEBUG_EXPR_DECL).

     As for value, it can be an arbitrary tree expression, but it is recommended that it be in a suitable form for a gimple assignment RHS.  It is not expected that user variables that could appear as var ever appear in value, because in the latter we'd have their SSA_NAMEs instead, but even if they were not in SSA form, user variables appearing in value are to be regarded as part of the executable code space, whereas those in var are to be regarded as part of the source code space.  There is no way to refer to the value bound to a user variable within a value expression.

     If value is GIMPLE_DEBUG_BIND_NOVALUE, debug information generation machinery is informed that the variable var is unbound, i.e., that its value is indeterminate, which sometimes means it is really unavailable, and other times that the compiler could not keep track of it.

     Block and location information for the newly-created stmt are taken from stmt, if given.

 -- GIMPLE function: tree gimple_debug_bind_get_var (gimple stmt)
     Return the user variable VAR that is bound at stmt.

 -- GIMPLE function: tree gimple_debug_bind_get_value (gimple stmt)
     Return the value expression that is bound to a user variable at stmt.

 -- GIMPLE function: tree * gimple_debug_bind_get_value_ptr (gimple stmt)
     Return a pointer to the value expression that is bound to a user variable at stmt.

 -- GIMPLE function: void gimple_debug_bind_set_var (gimple stmt, tree var)
     Modify the user variable bound at stmt to VAR.

 -- GIMPLE function: void gimple_debug_bind_set_value (gimple stmt, tree var)
     Modify the value bound to the user variable bound at stmt to VALUE.

 -- GIMPLE function: void gimple_debug_bind_reset_value (gimple stmt)
     Modify the value bound to the user variable bound at stmt so that the variable becomes unbound.

 -- GIMPLE function: bool gimple_debug_bind_has_value_p (gimple stmt)
     Return TRUE if stmt binds a user variable to a value, and FALSE if it unbinds the variable.

GIMPLE_EH_FILTER
----------------

 -- GIMPLE function: gimple gimple_build_eh_filter (tree types, gimple_seq failure)
     Build a GIMPLE_EH_FILTER statement.  TYPES are the filter's types.  FAILURE is a sequence with the filter's failure action.

 -- GIMPLE function: tree gimple_eh_filter_types (gimple g)
     Return the types handled by GIMPLE_EH_FILTER statement G.

 -- GIMPLE function: tree * gimple_eh_filter_types_ptr (gimple g)
     Return a pointer to the types handled by GIMPLE_EH_FILTER statement G.

 -- GIMPLE function: gimple_seq gimple_eh_filter_failure (gimple g)
     Return the sequence of statement to execute when GIMPLE_EH_FILTER statement fails.

 -- GIMPLE function: void gimple_eh_filter_set_types (gimple g, tree types)
     Set TYPES to be the set of types handled by GIMPLE_EH_FILTER G.

 -- GIMPLE function: void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
     Set FAILURE to be the sequence of statements to execute on failure for GIMPLE_EH_FILTER G.

 -- GIMPLE function: bool gimple_eh_filter_must_not_throw (gimple g)
     Return the EH_FILTER_MUST_NOT_THROW flag.

 -- GIMPLE function: void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
     Set the EH_FILTER_MUST_NOT_THROW flag.

GIMPLE_LABEL
------------

 -- GIMPLE function: gimple gimple_build_label (tree label)
     Build a GIMPLE_LABEL statement with corresponding to the tree label, LABEL.

 -- GIMPLE function: tree gimple_label_label (gimple g)
     Return the LABEL_DECL node used by GIMPLE_LABEL statement G.

 -- GIMPLE function: void gimple_label_set_label (gimple g, tree label)
     Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement G.

 -- GIMPLE function: gimple gimple_build_goto (tree dest)
     Build a GIMPLE_GOTO statement to label DEST.

 -- GIMPLE function: tree gimple_goto_dest (gimple g)
     Return the destination of the unconditional jump G.

 -- GIMPLE function: void gimple_goto_set_dest (gimple g, tree dest)
     Set DEST to be the destination of the unconditional jump G.

GIMPLE_NOP
----------

 -- GIMPLE function: gimple gimple_build_nop (void)
     Build a GIMPLE_NOP statement.

 -- GIMPLE function: bool gimple_nop_p (gimple g)
     Returns TRUE if statement G is a GIMPLE_NOP.

GIMPLE_OMP_ATOMIC_LOAD
----------------------

 -- GIMPLE function: gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
     Build a GIMPLE_OMP_ATOMIC_LOAD statement.  LHS is the left-hand side of the assignment.  RHS is the right-hand side of the assignment.

 -- GIMPLE function: void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
     Set the LHS of an atomic load.

 -- GIMPLE function: tree gimple_omp_atomic_load_lhs (gimple g)
     Get the LHS of an atomic load.

 -- GIMPLE function: void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
     Set the RHS of an atomic set.

 -- GIMPLE function: tree gimple_omp_atomic_load_rhs (gimple g)
     Get the RHS of an atomic set.

GIMPLE_OMP_ATOMIC_STORE
-----------------------

 -- GIMPLE function: gimple gimple_build_omp_atomic_store (tree val)
     Build a GIMPLE_OMP_ATOMIC_STORE statement. VAL is the value to be stored.

 -- GIMPLE function: void gimple_omp_atomic_store_set_val (gimple g, tree val)
     Set the value being stored in an atomic store.

 -- GIMPLE function: tree gimple_omp_atomic_store_val (gimple g)
     Return the value being stored in an atomic store.

GIMPLE_OMP_CONTINUE
-------------------

 -- GIMPLE function: gimple gimple_build_omp_continue (tree control_def, tree control_use)
     Build a GIMPLE_OMP_CONTINUE statement.  CONTROL_DEF is the definition of the control variable.  CONTROL_USE is the use of the control variable.

 -- GIMPLE function: tree gimple_omp_continue_control_def (gimple s)
     Return the definition of the control variable on a GIMPLE_OMP_CONTINUE in S.

 -- GIMPLE function: tree gimple_omp_continue_control_def_ptr (gimple s)
     Same as above, but return the pointer.

 -- GIMPLE function: tree gimple_omp_continue_set_control_def (gimple s)
     Set the control variable definition for a GIMPLE_OMP_CONTINUE statement in S.

 -- GIMPLE function: tree gimple_omp_continue_control_use (gimple s)
     Return the use of the control variable on a GIMPLE_OMP_CONTINUE in S.

 -- GIMPLE function: tree gimple_omp_continue_control_use_ptr (gimple s)
     Same as above, but return the pointer.

 -- GIMPLE function: tree gimple_omp_continue_set_control_use (gimple s)
     Set the control variable use for a GIMPLE_OMP_CONTINUE statement in S.

GIMPLE_OMP_CRITICAL
-------------------

 -- GIMPLE function: gimple gimple_build_omp_critical (gimple_seq body, tree name)
     Build a GIMPLE_OMP_CRITICAL statement. BODY is the sequence of statements for which only one thread can execute.  NAME is an optional identifier for this critical block.

 -- GIMPLE function: tree gimple_omp_critical_name (gimple g)
     Return the name associated with OMP_CRITICAL statement G.

 -- GIMPLE function: tree * gimple_omp_critical_name_ptr (gimple g)
     Return a pointer to the name associated with OMP critical statement G.

 -- GIMPLE function: void gimple_omp_critical_set_name (gimple g, tree name)
     Set NAME to be the name associated with OMP critical statement G.

GIMPLE_OMP_FOR
--------------

 -- GIMPLE function: gimple gimple_build_omp_for (gimple_seq body,
     tree clauses, tree index, tree initial, tree final, tree incr,
     gimple_seq pre_body, enum tree_code omp_for_cond)
     Build a GIMPLE_OMP_FOR statement. BODY is sequence of statements inside the for loop.  CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,  lastprivate, reductions, ordered, schedule, and nowait.  PRE_BODY is the sequence of statements that are loop invariant.  INDEX is the index variable.  INITIAL is the initial value of INDEX.  FINAL is final value of INDEX.  OMP_FOR_COND is the predicate used to compare INDEX and FINAL.  INCR is the increment expression.

 -- GIMPLE function: tree gimple_omp_for_clauses (gimple g)
     Return the clauses associated with OMP_FOR G.

 -- GIMPLE function: tree * gimple_omp_for_clauses_ptr (gimple g)
     Return a pointer to the OMP_FOR G.

 -- GIMPLE function: void gimple_omp_for_set_clauses (gimple g, tree clauses)
     Set CLAUSES to be the list of clauses associated with OMP_FOR G.

 -- GIMPLE function: tree gimple_omp_for_index (gimple g)
     Return the index variable for OMP_FOR G.

 -- GIMPLE function: tree * gimple_omp_for_index_ptr (gimple g)
     Return a pointer to the index variable for OMP_FOR G.

 -- GIMPLE function: void gimple_omp_for_set_index (gimple g, tree index)
     Set INDEX to be the index variable for OMP_FOR G.

 -- GIMPLE function: tree gimple_omp_for_initial (gimple g)
     Return the initial value for OMP_FOR G.

 -- GIMPLE function: tree * gimple_omp_for_initial_ptr (gimple g)
     Return a pointer to the initial value for OMP_FOR G.

 -- GIMPLE function: void gimple_omp_for_set_initial (gimple g, tree initial)
     Set INITIAL to be the initial value for OMP_FOR G.

 -- GIMPLE function: tree gimple_omp_for_final (gimple g)
     Return the final value for OMP_FOR G.

 -- GIMPLE function: tree * gimple_omp_for_final_ptr (gimple g)
     turn a pointer to the final value for OMP_FOR G.

 -- GIMPLE function: void gimple_omp_for_set_final (gimple g, tree final)
     Set FINAL to be the final value for OMP_FOR G.

 -- GIMPLE function: tree gimple_omp_for_incr (gimple g)
     Return the increment value for OMP_FOR G.

 -- GIMPLE function: tree * gimple_omp_for_incr_ptr (gimple g)
     Return a pointer to the increment value for OMP_FOR G.

 -- GIMPLE function: void gimple_omp_for_set_incr (gimple g, tree incr)
     Set INCR to be the increment value for OMP_FOR G.

 -- GIMPLE function: gimple_seq gimple_omp_for_pre_body (gimple g)
     Return the sequence of statements to execute before the OMP_FOR statement G starts.

 -- GIMPLE function: void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
     Set PRE_BODY to be the sequence of statements to execute before the OMP_FOR statement G starts.

 -- GIMPLE function: void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
     Set COND to be the condition code for OMP_FOR G.

 -- GIMPLE function: enum tree_code gimple_omp_for_cond (gimple g)
     Return the condition code associated with OMP_FOR G.

GIMPLE_OMP_MASTER
-----------------

 -- GIMPLE function: gimple gimple_build_omp_master (gimple_seq body)
     Build a GIMPLE_OMP_MASTER statement. BODY is the sequence of statements to be executed by just the master.

GIMPLE_OMP_ORDERED
------------------

 -- GIMPLE function: gimple gimple_build_omp_ordered (gimple_seq body)
     Build a GIMPLE_OMP_ORDERED statement.

BODY is the sequence of statements inside a loop that will executed in sequence.

GIMPLE_OMP_PARALLEL
-------------------

 -- GIMPLE function: gimple gimple_build_omp_parallel (gimple_seq
     body, tree clauses, tree child_fn, tree data_arg)
     Build a GIMPLE_OMP_PARALLEL statement.

BODY is sequence of statements which are executed in parallel. CLAUSES, are the OMP parallel construct's clauses.  CHILD_FN is the function created for the parallel threads to execute. DATA_ARG are the shared data argument(s).

 -- GIMPLE function: bool gimple_omp_parallel_combined_p (gimple g)
     Return true if OMP parallel statement G has the GF_OMP_PARALLEL_COMBINED flag set.

 -- GIMPLE function: void gimple_omp_parallel_set_combined_p (gimple g)
     Set the GF_OMP_PARALLEL_COMBINED field in OMP parallel statement G.

 -- GIMPLE function: gimple_seq gimple_omp_body (gimple g)
     Return the body for the OMP statement G.

 -- GIMPLE function: void gimple_omp_set_body (gimple g, gimple_seq body)
     Set BODY to be the body for the OMP statement G.

 -- GIMPLE function: tree gimple_omp_parallel_clauses (gimple g)
     Return the clauses associated with OMP_PARALLEL G.

 -- GIMPLE function: tree * gimple_omp_parallel_clauses_ptr (gimple g)
     Return a pointer to the clauses associated with OMP_PARALLEL G.

 -- GIMPLE function: void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
     Set CLAUSES to be the list of clauses associated with OMP_PARALLEL G.

 -- GIMPLE function: tree gimple_omp_parallel_child_fn (gimple g)
     Return the child function used to hold the body of OMP_PARALLEL G.

 -- GIMPLE function: tree * gimple_omp_parallel_child_fn_ptr (gimple g)
     Return a pointer to the child function used to hold the body of OMP_PARALLEL G.

 -- GIMPLE function: void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
     Set CHILD_FN to be the child function for OMP_PARALLEL G.

 -- GIMPLE function: tree gimple_omp_parallel_data_arg (gimple g)
     Return the artificial argument used to send variables and values from the parent to the children threads in OMP_PARALLEL G.

 -- GIMPLE function: tree * gimple_omp_parallel_data_arg_ptr (gimple g)
     Return a pointer to the data argument for OMP_PARALLEL G.

 -- GIMPLE function: void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
     Set DATA_ARG to be the data argument for OMP_PARALLEL G.

GIMPLE_OMP_RETURN
-----------------

 -- GIMPLE function: gimple gimple_build_omp_return (bool wait_p)
     Build a GIMPLE_OMP_RETURN statement. WAIT_P is true if this is a non-waiting return.

 -- GIMPLE function: void gimple_omp_return_set_nowait (gimple s)
     Set the nowait flag on GIMPLE_OMP_RETURN statement S.

 -- GIMPLE function: bool gimple_omp_return_nowait_p (gimple g)
     Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT flag set.

GIMPLE_OMP_SECTION
------------------

 -- GIMPLE function: gimple gimple_build_omp_section (gimple_seq body)
     Build a GIMPLE_OMP_SECTION statement for a sections statement.

BODY is the sequence of statements in the section.

 -- GIMPLE function: bool gimple_omp_section_last_p (gimple g)
     Return true if OMP section statement G has the GF_OMP_SECTION_LAST flag set.

 -- GIMPLE function: void gimple_omp_section_set_last (gimple g)
     Set the GF_OMP_SECTION_LAST flag on G.

GIMPLE_OMP_SECTIONS
-------------------

 -- GIMPLE function: gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
     Build a GIMPLE_OMP_SECTIONS statement. BODY is a sequence of section statements.  CLAUSES are any of the OMP sections construct's clauses: private, firstprivate, lastprivate, reduction, and nowait.

 -- GIMPLE function: gimple gimple_build_omp_sections_switch (void)
     Build a GIMPLE_OMP_SECTIONS_SWITCH statement.

 -- GIMPLE function: tree gimple_omp_sections_control (gimple g)
     Return the control variable associated with the GIMPLE_OMP_SECTIONS in G.

 -- GIMPLE function: tree * gimple_omp_sections_control_ptr (gimple g)
     Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS in G.

 -- GIMPLE function: void gimple_omp_sections_set_control (gimple g, tree control)
     Set CONTROL to be the set of clauses associated with the GIMPLE_OMP_SECTIONS in G.

 -- GIMPLE function: tree gimple_omp_sections_clauses (gimple g)
     Return the clauses associated with OMP_SECTIONS G.

 -- GIMPLE function: tree * gimple_omp_sections_clauses_ptr (gimple g)
     Return a pointer to the clauses associated with OMP_SECTIONS G.

 -- GIMPLE function: void gimple_omp_sections_set_clauses (gimple g, tree clauses)
     Set CLAUSES to be the set of clauses associated with OMP_SECTIONS G.

GIMPLE_OMP_SINGLE
-----------------

 -- GIMPLE function: gimple gimple_build_omp_single (gimple_seq body, tree clauses)
     Build a GIMPLE_OMP_SINGLE statement. BODY is the sequence of statements that will be executed once.  CLAUSES are any of the OMP single construct's clauses: private, firstprivate, copyprivate, nowait.

 -- GIMPLE function: tree gimple_omp_single_clauses (gimple g)
     Return the clauses associated with OMP_SINGLE G.

 -- GIMPLE function: tree * gimple_omp_single_clauses_ptr (gimple g)
     Return a pointer to the clauses associated with OMP_SINGLE G.

 -- GIMPLE function: void gimple_omp_single_set_clauses (gimple g, tree clauses)
     Set CLAUSES to be the clauses associated with OMP_SINGLE G.

GIMPLE_PHI
----------

 -- GIMPLE function: unsigned gimple_phi_capacity (gimple g)
     Return the maximum number of arguments supported by GIMPLE_PHI G.

 -- GIMPLE function: unsigned gimple_phi_num_args (gimple g)
     Return the number of arguments in GIMPLE_PHI G. This must always be exactly the number of incoming edges for the basic block holding G.

 -- GIMPLE function: tree gimple_phi_result (gimple g)
     Return the SSA name created by GIMPLE_PHI G.

 -- GIMPLE function: tree * gimple_phi_result_ptr (gimple g)
     Return a pointer to the SSA name created by GIMPLE_PHI G.

 -- GIMPLE function: void gimple_phi_set_result (gimple g, tree result)
     Set RESULT to be the SSA name created by GIMPLE_PHI G.

 -- GIMPLE function: struct phi_arg_d * gimple_phi_arg (gimple g, index)
     Return the PHI argument corresponding to incoming edge INDEX for GIMPLE_PHI G.

 -- GIMPLE function: void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
     Set PHIARG to be the argument corresponding to incoming edge INDEX for GIMPLE_PHI G.

GIMPLE_RESX
-----------

 -- GIMPLE function: gimple gimple_build_resx (int region)
     Build a GIMPLE_RESX statement which is a statement.  This statement is a placeholder for _Unwind_Resume before we know if a function call or a branch is needed.  REGION is the exception region from which control is flowing.

 -- GIMPLE function: int gimple_resx_region (gimple g)
     Return the region number for GIMPLE_RESX G.

 -- GIMPLE function: void gimple_resx_set_region (gimple g, int region)
     Set REGION to be the region number for GIMPLE_RESX G.

GIMPLE_RETURN
-------------

 -- GIMPLE function: gimple gimple_build_return (tree retval)
     Build a GIMPLE_RETURN statement whose return value is retval.

 -- GIMPLE function: tree gimple_return_retval (gimple g)
     Return the return value for GIMPLE_RETURN G.

 -- GIMPLE function: void gimple_return_set_retval (gimple g, tree retval)
     Set RETVAL to be the return value for GIMPLE_RETURN G.

GIMPLE_SWITCH
-------------

 -- GIMPLE function: gimple gimple_build_switch (tree index, tree
     default_label, VEC(tree,heap) *args)
     Build a GIMPLE_SWITCH statement.  INDEX is the index variable to switch on, and DEFAULT_LABEL represents the default label. ARGS is a vector of CASE_LABEL_EXPR trees that contain the non-default case labels.  Each label is a tree of code CASE_LABEL_EXPR.

 -- GIMPLE function: unsigned gimple_switch_num_labels (gimple g)
     Return the number of labels associated with the switch statement G.

 -- GIMPLE function: void gimple_switch_set_num_labels (gimple g,
     unsigned nlabels)
     Set NLABELS to be the number of labels for the switch statement G.

 -- GIMPLE function: tree gimple_switch_index (gimple g)
     Return the index variable used by the switch statement G.

 -- GIMPLE function: void gimple_switch_set_index (gimple g, tree index)
     Set INDEX to be the index variable for switch statement G.

 -- GIMPLE function: tree gimple_switch_label (gimple g, unsigned index)
     Return the label numbered INDEX. The default label is 0, followed by any labels in a switch statement.

 -- GIMPLE function: void gimple_switch_set_label (gimple g, unsigned
     index, tree label)
     Set the label number INDEX to LABEL. 0 is always the default label.

 -- GIMPLE function: tree gimple_switch_default_label (gimple g)
     Return the default label for a switch statement.

 -- GIMPLE function: void gimple_switch_set_default_label (gimple g,
     tree label)
     Set the default label for a switch statement.

GIMPLE_TRY
----------

 -- GIMPLE function: gimple gimple_build_try (gimple_seq eval,
     gimple_seq cleanup, unsigned int kind)
     Build a GIMPLE_TRY statement.  EVAL is a sequence with the expression to evaluate.  CLEANUP is a sequence of statements to run at clean-up time.  KIND is the enumeration value GIMPLE_TRY_CATCH if this statement denotes a try/catch construct or GIMPLE_TRY_FINALLY if this statement denotes a try/finally construct.

 -- GIMPLE function: enum gimple_try_flags gimple_try_kind (gimple g)
     Return the kind of try block represented by GIMPLE_TRY G. This is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.

 -- GIMPLE function: bool gimple_try_catch_is_cleanup (gimple g)
     Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

 -- GIMPLE function: gimple_seq gimple_try_eval (gimple g)
     Return the sequence of statements used as the body for GIMPLE_TRY G.

 -- GIMPLE function: gimple_seq gimple_try_cleanup (gimple g)
     Return the sequence of statements used as the cleanup body for GIMPLE_TRY G.

 -- GIMPLE function: void gimple_try_set_catch_is_cleanup (gimple g,
     bool catch_is_cleanup)
     Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

 -- GIMPLE function: void gimple_try_set_eval (gimple g, gimple_seq eval)
     Set EVAL to be the sequence of statements to use as the body for GIMPLE_TRY G.

 -- GIMPLE function: void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
     Set CLEANUP to be the sequence of statements to use as the cleanup body for GIMPLE_TRY G.

GIMPLE_WITH_CLEANUP_EXPR
------------------------

 -- GIMPLE function: gimple gimple_build_wce (gimple_seq cleanup)
     Build a GIMPLE_WITH_CLEANUP_EXPR statement.  CLEANUP is the clean-up expression.

 -- GIMPLE function: gimple_seq gimple_wce_cleanup (gimple g)
     Return the cleanup sequence for cleanup statement G.

 -- GIMPLE function: void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
     Set CLEANUP to be the cleanup sequence for G.

 -- GIMPLE function: bool gimple_wce_cleanup_eh_only (gimple g)
     Return the CLEANUP_EH_ONLY flag for a WCE tuple.

 -- GIMPLE function: void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
     Set the CLEANUP_EH_ONLY flag for a WCE tuple.

GIMPLE sequences
================

GIMPLE sequences are the tuple equivalent of STATEMENT_LIST's used in GENERIC.  They are used to chain statements together, and when used in conjunction with sequence iterators, provide a framework for iterating through statements.

GIMPLE sequences are of type struct gimple_sequence, but are more commonly passed by reference to functions dealing with sequences. The type for a sequence pointer is gimple_seq which is the same as struct gimple_sequence *.  When declaring a local sequence, you can define a local variable of type struct gimple_sequence. When declaring a sequence allocated on the garbage collected heap, use the function gimple_seq_alloc documented below.

There are convenience functions for iterating through sequences in the section entitled Sequence Iterators.

Below is a list of functions to manipulate and query sequences.

 -- GIMPLE function: void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
     Link a gimple statement to the end of the sequence *SEQ if G is not NULL.  If *SEQ is NULL, allocate a sequence before linking.

 -- GIMPLE function: void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
     Append sequence SRC to the end of sequence *DEST if SRC is not NULL.  If *DEST is NULL, allocate a new sequence before appending.

 -- GIMPLE function: gimple_seq gimple_seq_deep_copy (gimple_seq src)
     Perform a deep copy of sequence SRC and return the result.

 -- GIMPLE function: gimple_seq gimple_seq_reverse (gimple_seq seq)
     Reverse the order of the statements in the sequence SEQ.  Return SEQ.

 -- GIMPLE function: gimple gimple_seq_first (gimple_seq s)
     Return the first statement in sequence S.

 -- GIMPLE function: gimple gimple_seq_last (gimple_seq s)
     Return the last statement in sequence S.

 -- GIMPLE function: void gimple_seq_set_last (gimple_seq s, gimple last)
     Set the last statement in sequence S to the statement in LAST.

 -- GIMPLE function: void gimple_seq_set_first (gimple_seq s, gimple first)
     Set the first statement in sequence S to the statement in FIRST.

 -- GIMPLE function: void gimple_seq_init (gimple_seq s)
     Initialize sequence S to an empty sequence.

 -- GIMPLE function: gimple_seq gimple_seq_alloc (void)
     Allocate a new sequence in the garbage collected store and return it.

 -- GIMPLE function: void gimple_seq_copy (gimple_seq dest, gimple_seq src)
     Copy the sequence SRC into the sequence DEST.

 -- GIMPLE function: bool gimple_seq_empty_p (gimple_seq s)
     Return true if the sequence S is empty.

 -- GIMPLE function: gimple_seq bb_seq (basic_block bb)
     Returns the sequence of statements in BB.

 -- GIMPLE function: void set_bb_seq (basic_block bb, gimple_seq seq)
     Sets the sequence of statements in BB to SEQ.

 -- GIMPLE function: bool gimple_seq_singleton_p (gimple_seq seq)
     Determine whether SEQ contains exactly one statement.

Sequence iterators
==================

Sequence iterators are convenience constructs for iterating through statements in a sequence.  Given a sequence SEQ, here is a typical use of gimple sequence iterators:

     gimple_stmt_iterator gsi;

     for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
       {
         gimple g = gsi_stmt (gsi);
         /* Do something with gimple statement G.  */
       }

Backward iterations are possible:

             for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))

Forward and backward iterations on basic blocks are possible with gsi_start_bb and gsi_last_bb.

In the documentation below we sometimes refer to enum gsi_iterator_update.  The valid options for this enumeration are:

  * GSI_NEW_STMT Only valid when a single statement is added.  Move the iterator to it.

  * GSI_SAME_STMT Leave the iterator at the same statement.

  * GSI_CONTINUE_LINKING Move iterator to whatever position is suitable for linking other statements in the same direction.

Below is a list of the functions used to manipulate and use statement iterators.

 -- GIMPLE function: gimple_stmt_iterator gsi_start (gimple_seq seq)
     Return a new iterator pointing to the sequence SEQ's first statement.  If SEQ is empty, the iterator's basic block is NULL. Use gsi_start_bb instead when the iterator needs to always have the correct basic block set.

 -- GIMPLE function: gimple_stmt_iterator gsi_start_bb (basic_block bb)
     Return a new iterator pointing to the first statement in basic block BB.

 -- GIMPLE function: gimple_stmt_iterator gsi_last (gimple_seq seq)
     Return a new iterator initially pointing to the last statement of sequence SEQ.  If SEQ is empty, the iterator's basic block is NULL.  Use gsi_last_bb instead when the iterator needs to always have the correct basic block set.

 -- GIMPLE function: gimple_stmt_iterator gsi_last_bb (basic_block bb)
     Return a new iterator pointing to the last statement in basic block BB.

 -- GIMPLE function: bool gsi_end_p (gimple_stmt_iterator i)
     Return TRUE if at the end of I.

 -- GIMPLE function: bool gsi_one_before_end_p (gimple_stmt_iterator i)
     Return TRUE if we're one statement before the end of I.

 -- GIMPLE function: void gsi_next (gimple_stmt_iterator *i)
     Advance the iterator to the next gimple statement.

 -- GIMPLE function: void gsi_prev (gimple_stmt_iterator *i)
     Advance the iterator to the previous gimple statement.

 -- GIMPLE function: gimple gsi_stmt (gimple_stmt_iterator i)
     Return the current stmt.

 -- GIMPLE function: gimple_stmt_iterator gsi_after_labels (basic_block bb)
     Return a block statement iterator that points to the first non-label statement in block BB.

 -- GIMPLE function: gimple * gsi_stmt_ptr (gimple_stmt_iterator *i)
     Return a pointer to the current stmt.

 -- GIMPLE function: basic_block gsi_bb (gimple_stmt_iterator i)
     Return the basic block associated with this iterator.

 -- GIMPLE function: gimple_seq gsi_seq (gimple_stmt_iterator i)
     Return the sequence associated with this iterator.

 -- GIMPLE function: void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
     Remove the current stmt from the sequence.  The iterator is updated to point to the next statement.  When REMOVE_EH_INFO is true we remove the statement pointed to by iterator I from the EH tables.  Otherwise we do not modify the EH tables.  Generally, REMOVE_EH_INFO should be true when the statement is going to be removed from the IL and not reinserted elsewhere.

 -- GIMPLE function: void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
     Links the sequence of statements SEQ before the statement pointed by iterator I.  MODE indicates what to do with the iterator after insertion (see enum gsi_iterator_update above).

 -- GIMPLE function: void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
     Links statement G before the statement pointed-to by iterator I. Updates iterator I according to MODE.

 -- GIMPLE function: void gsi_link_seq_after (gimple_stmt_iterator *i,
     gimple_seq seq, enum gsi_iterator_update mode)
     Links sequence SEQ after the statement pointed-to by iterator I. MODE is as in gsi_insert_after.

 -- GIMPLE function: void gsi_link_after (gimple_stmt_iterator *i,
     gimple g, enum gsi_iterator_update mode)
     Links statement G after the statement pointed-to by iterator I. MODE is as in gsi_insert_after.

 -- GIMPLE function: gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
     Move all statements in the sequence after I to a new sequence. Return this new sequence.

 -- GIMPLE function: gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
     Move all statements in the sequence before I to a new sequence. Return this new sequence.

 -- GIMPLE function: void gsi_replace (gimple_stmt_iterator *i,
     gimple stmt, bool update_eh_info)
     Replace the statement pointed-to by I to STMT.  If UPDATE_EH_INFO is true, the exception handling information of the original statement is moved to the new statement.

 -- GIMPLE function: void gsi_insert_before (gimple_stmt_iterator *i,
     gimple stmt, enum gsi_iterator_update mode)
     Insert statement STMT before the statement pointed-to by iterator I, update STMT's basic block and scan it for new operands.  MODE specifies how to update iterator I after insertion (see enum gsi_iterator_update).

 -- GIMPLE function: void gsi_insert_seq_before (gimple_stmt_iterator *i,
     gimple_seq seq, enum gsi_iterator_update mode)
     Like gsi_insert_before, but for all the statements in SEQ.

 -- GIMPLE function: void gsi_insert_after (gimple_stmt_iterator *i,
     gimple stmt, enum gsi_iterator_update mode)
     Insert statement STMT after the statement pointed-to by iterator I, update STMT's basic block and scan it for new operands.  MODE specifies how to update iterator I after insertion (see enum gsi_iterator_update).

 -- GIMPLE function: void gsi_insert_seq_after (gimple_stmt_iterator *i,
     gimple_seq seq, enum gsi_iterator_update mode)
     Like gsi_insert_after, but for all the statements in SEQ.

 -- GIMPLE function: gimple_stmt_iterator gsi_for_stmt (gimple stmt)
     Finds iterator for STMT.

 -- GIMPLE function: void gsi_move_after (gimple_stmt_iterator *from,
     gimple_stmt_iterator *to)
     Move the statement at FROM so it comes right after the statement at TO.

 -- GIMPLE function: void gsi_move_before (gimple_stmt_iterator *from,
     gimple_stmt_iterator *to)
     Move the statement at FROM so it comes right before the statement at TO.

 -- GIMPLE function: void gsi_move_to_bb_end (gimple_stmt_iterator *from,
     basic_block bb)
     Move the statement at FROM to the end of basic block BB.

 -- GIMPLE function: void gsi_insert_on_edge (edge e, gimple stmt)
     Add STMT to the pending list of edge E.  No actual insertion is made until a call to gsi_commit_edge_inserts() is made.

 -- GIMPLE function: void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
     Add the sequence of statements in SEQ to the pending list of edge E.  No actual insertion is made until a call to gsi_commit_edge_inserts() is made.

 -- GIMPLE function: basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
     Similar to gsi_insert_on_edge+gsi_commit_edge_inserts.  If a new block has to be created, it is returned.

 -- GIMPLE function: void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
     Commit insertions pending at edge E.  If a new block is created, set NEW_BB to this block, otherwise set it to NULL.

 -- GIMPLE function: void gsi_commit_edge_inserts (void)
     This routine will commit all pending edge insertions, creating any new basic blocks which are necessary.

Adding a new GIMPLE statement code
==================================

The first step in adding a new GIMPLE statement code, is modifying the file gimple.def, which contains all the GIMPLE codes.  Then you must add a corresponding structure, and an entry in union gimple_statement_d, both of which are located in gimple.h.  This in turn, will require you to add a corresponding GTY tag in gsstruct.def, and code to handle this tag in gss_for_code which is located in gimple.c.

In order for the garbage collector to know the size of the structure you created in gimple.h, you need to add a case to handle your new GIMPLE statement in gimple_size which is located in gimple.c.

You will probably want to create a function to build the new gimple statement in gimple.c.  The function should be called gimple_build_NEW-TUPLE-NAME, and should return the new tuple of type gimple.

If your new statement requires accessors for any members or operands it may have, put simple inline accessors in gimple.h and any non-trivial accessors in gimple.c with a corresponding prototype in gimple.h.

Statement and operand traversals
================================

There are two functions available for walking statements and sequences: walk_gimple_stmt and walk_gimple_seq, accordingly, and a third function for walking the operands in a statement: walk_gimple_op.

 -- GIMPLE function: tree walk_gimple_stmt (gimple_stmt_iterator *gsi,
     walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
     This function is used to walk the current statement in GSI, optionally using traversal state stored in WI.  If WI is NULL, no state is kept during the traversal.

     The callback CALLBACK_STMT is called.  If CALLBACK_STMT returns true, it means that the callback function has handled all the operands of the statement and it is not necessary to walk its operands.

     If CALLBACK_STMT is NULL or it returns false, CALLBACK_OP is called on each operand of the statement via walk_gimple_op.  If walk_gimple_op returns non-NULL for any operand, the remaining operands are not scanned.

     The return value is that returned by the last call to walk_gimple_op, or NULL_TREE if no CALLBACK_OP is specified.

 -- GIMPLE function: tree walk_gimple_op (gimple stmt,
     walk_tree_fn callback_op, struct walk_stmt_info *wi)
     Use this function to walk the operands of statement STMT.  Every operand is walked via walk_tree with optional state information in WI.

     CALLBACK_OP is called on each operand of STMT via walk_tree. Additional parameters to walk_tree must be stored in WI.  For each operand OP, walk_tree is called as:

          walk_tree (&OP, CALLBACK_OP, WI, PSET)

     If CALLBACK_OP returns non-NULL for an operand, the remaining operands are not scanned.  The return value is that returned by the last call to walk_tree, or NULL_TREE if no CALLBACK_OP is specified.

 -- GIMPLE function: tree walk_gimple_seq (gimple_seq seq,
     walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
     This function walks all the statements in the sequence SEQ calling walk_gimple_stmt on each one.  WI is as in walk_gimple_stmt.  If walk_gimple_stmt returns non-NULL, the walk is stopped and the value returned.  Otherwise, all the statements are walked and NULL_TREE returned.