OSDN Git Service

2008-09-21 Diego Novillo <dnovillo@google.com>
authordnovillo <dnovillo@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 21 Sep 2008 15:05:14 +0000 (15:05 +0000)
committerdnovillo <dnovillo@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 21 Sep 2008 15:05:14 +0000 (15:05 +0000)
* doc/gccint.texi: Include generic.texi and gimple.texi.
Re-order index.
* doc/tree-ssa.texi (GENERIC): Move to generic.texi.
(GIMPLE): Move to gimple.texi.
(Annotations): Remove references to to stmt_ann_t and
ssa_name_ann_t.
(SSA Operands): Rename from 'Statement Operands'.
* doc/generic.texi: New.
* doc/gimple.texi: New.
* Makefile.in (TEXI_GCCINT_FILES): Add generic.texi and
gimple.texi.
* Makefile.in (TEXI_GCCINT_FILES):
* gimple.c (gimple_copy_call_skip_args): Rename from
giple_copy_call_skip_args.  Update all users.
* doc/gimple.texi (gimple_copy_call_skip_args): Document.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@140527 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/Makefile.in
gcc/doc/gccint.texi
gcc/doc/generic.texi [new file with mode: 0644]
gcc/doc/gimple.texi [new file with mode: 0644]
gcc/doc/tree-ssa.texi
gcc/gimple.c
gcc/gimple.h
gcc/ipa-cp.c

index 1ce145f..ebb8875 100644 (file)
@@ -1,3 +1,21 @@
+2008-09-21  Diego Novillo  <dnovillo@google.com>
+
+       * doc/gccint.texi: Include generic.texi and gimple.texi.
+       Re-order index.
+       * doc/tree-ssa.texi (GENERIC): Move to generic.texi.
+       (GIMPLE): Move to gimple.texi.
+       (Annotations): Remove references to to stmt_ann_t and
+       ssa_name_ann_t.
+       (SSA Operands): Rename from 'Statement Operands'.
+       * doc/generic.texi: New.
+       * doc/gimple.texi: New.
+       * Makefile.in (TEXI_GCCINT_FILES): Add generic.texi and
+       gimple.texi.
+       * Makefile.in (TEXI_GCCINT_FILES):
+       * gimple.c (gimple_copy_call_skip_args): Rename from
+       giple_copy_call_skip_args.  Update all users.
+       * doc/gimple.texi (gimple_copy_call_skip_args): Document.
+
 2008-09-21  Ira Rosen  <irar@il.ibm.com>
 
        PR tree-optimization/37539
index b75c678..f067a91 100644 (file)
@@ -3844,7 +3844,7 @@ TEXI_GCCINT_FILES = gccint.texi gcc-common.texi gcc-vers.texi             \
         configfiles.texi collect2.texi headerdirs.texi funding.texi    \
         gnu.texi gpl_v3.texi fdl.texi contrib.texi languages.texi      \
         sourcebuild.texi gty.texi libgcc.texi cfg.texi tree-ssa.texi   \
-        loop.texi
+        loop.texi generic.texi gimple.texi
 
 TEXI_GCCINSTALL_FILES = install.texi install-old.texi fdl.texi         \
         gcc-common.texi gcc-vers.texi
index 9fe28c0..b4b559e 100644 (file)
@@ -110,8 +110,10 @@ Additional tutorial information is linked to from
 * Passes::          Order of passes, what they do, and what each file is for.
 * Trees::           The source representation used by the C and C++ front ends.
 * RTL::             The intermediate representation that most passes work on.
+* GENERIC::         Language-independent representation generated by Front Ends
+* GIMPLE::          Tuple representation used by Tree SSA optimizers
+* Tree SSA::        Analysis and optimization of GIMPLE
 * Control Flow::    Maintaining and manipulating the control flow graph.
-* Tree SSA::        Analysis and optimization of the tree representation.
 * Loop Analysis and Representation:: Analysis and representation of loops
 * Machine Desc::    How to write machine description instruction patterns.
 * Target Macros::   How to write the machine description C macros and functions.
@@ -142,9 +144,11 @@ Additional tutorial information is linked to from
 @include options.texi
 @include passes.texi
 @include c-tree.texi
+@include rtl.texi
+@include generic.texi
+@include gimple.texi
 @include tree-ssa.texi
 @include loop.texi
-@include rtl.texi
 @include cfg.texi
 @include md.texi
 @include tm.texi
diff --git a/gcc/doc/generic.texi b/gcc/doc/generic.texi
new file mode 100644 (file)
index 0000000..14284cc
--- /dev/null
@@ -0,0 +1,179 @@
+@c Copyright (c) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+@c Free Software Foundation, Inc.
+@c This is part of the GCC manual.
+@c For copying conditions, see the file gcc.texi.
+
+@c ---------------------------------------------------------------------
+@c GENERIC
+@c ---------------------------------------------------------------------
+
+@node GENERIC
+@chapter GENERIC
+@cindex GENERIC
+
+The purpose of GENERIC is simply to provide a
+language-independent way of representing an entire function in
+trees.  To this end, it was necessary to add a few new tree codes
+to the back end, but most everything was already there.  If you
+can express it with the codes in @code{gcc/tree.def}, it's
+GENERIC@.
+
+Early on, there was a great deal of debate about how to think
+about statements in a tree IL@.  In GENERIC, a statement is
+defined as any expression whose value, if any, is ignored.  A
+statement will always have @code{TREE_SIDE_EFFECTS} set (or it
+will be discarded), but a non-statement expression may also have
+side effects.  A @code{CALL_EXPR}, for instance.
+
+It would be possible for some local optimizations to work on the
+GENERIC form of a function; indeed, the adapted tree inliner
+works fine on GENERIC, but the current compiler performs inlining
+after lowering to GIMPLE (a restricted form described in the next
+section). Indeed, currently the frontends perform this lowering
+before handing off to @code{tree_rest_of_compilation}, but this
+seems inelegant.
+
+If necessary, a front end can use some language-dependent tree
+codes in its GENERIC representation, so long as it provides a
+hook for converting them to GIMPLE and doesn't expect them to
+work with any (hypothetical) optimizers that run before the
+conversion to GIMPLE@. The intermediate representation used while
+parsing C and C++ looks very little like GENERIC, but the C and
+C++ gimplifier hooks are perfectly happy to take it as input and
+spit out GIMPLE@.
+
+@menu
+* Statements::
+@end menu
+
+@node Statements
+@section Statements
+@cindex Statements
+
+Most statements in GIMPLE are assignment statements, represented by
+@code{GIMPLE_ASSIGN}.  No other C expressions can appear at statement level;
+a reference to a volatile object is converted into a
+@code{GIMPLE_ASSIGN}.
+
+There are also several varieties of complex statements.
+
+@menu
+* Blocks::
+* Statement Sequences::
+* Empty Statements::
+* Jumps::
+* Cleanups::
+@end menu
+
+@node Blocks
+@subsection Blocks
+@cindex Blocks
+
+Block scopes and the variables they declare in GENERIC are
+expressed using the @code{BIND_EXPR} code, which in previous
+versions of GCC was primarily used for the C statement-expression
+extension.
+
+Variables in a block are collected into @code{BIND_EXPR_VARS} in
+declaration order.  Any runtime initialization is moved out of
+@code{DECL_INITIAL} and into a statement in the controlled block.
+When gimplifying from C or C++, this initialization replaces the
+@code{DECL_STMT}.
+
+Variable-length arrays (VLAs) complicate this process, as their
+size often refers to variables initialized earlier in the block.
+To handle this, we currently split the block at that point, and
+move the VLA into a new, inner @code{BIND_EXPR}.  This strategy
+may change in the future.
+
+A C++ program will usually contain more @code{BIND_EXPR}s than
+there are syntactic blocks in the source code, since several C++
+constructs have implicit scopes associated with them.  On the
+other hand, although the C++ front end uses pseudo-scopes to
+handle cleanups for objects with destructors, these don't
+translate into the GIMPLE form; multiple declarations at the same
+level use the same @code{BIND_EXPR}.
+
+@node Statement Sequences
+@subsection Statement Sequences
+@cindex Statement Sequences
+
+Multiple statements at the same nesting level are collected into
+a @code{STATEMENT_LIST}.  Statement lists are modified and
+traversed using the interface in @samp{tree-iterator.h}.
+
+@node Empty Statements
+@subsection Empty Statements
+@cindex Empty Statements
+
+Whenever possible, statements with no effect are discarded.  But
+if they are nested within another construct which cannot be
+discarded for some reason, they are instead replaced with an
+empty statement, generated by @code{build_empty_stmt}.
+Initially, all empty statements were shared, after the pattern of
+the Java front end, but this caused a lot of trouble in practice.
+
+An empty statement is represented as @code{(void)0}.
+
+@node Jumps
+@subsection Jumps
+@cindex Jumps
+
+Other jumps are expressed by either @code{GOTO_EXPR} or
+@code{RETURN_EXPR}.
+
+The operand of a @code{GOTO_EXPR} must be either a label or a
+variable containing the address to jump to.
+
+The operand of a @code{RETURN_EXPR} is either @code{NULL_TREE},
+@code{RESULT_DECL}, or a @code{MODIFY_EXPR} which sets the return
+value.  It would be nice to move the @code{MODIFY_EXPR} into a
+separate statement, but the special return semantics in
+@code{expand_return} make that difficult.  It may still happen in
+the future, perhaps by moving most of that logic into
+@code{expand_assignment}.
+
+@node Cleanups
+@subsection Cleanups
+@cindex Cleanups
+
+Destructors for local C++ objects and similar dynamic cleanups are
+represented in GIMPLE by a @code{TRY_FINALLY_EXPR}.
+@code{TRY_FINALLY_EXPR} has two operands, both of which are a sequence
+of statements to execute.  The first sequence is executed.  When it
+completes the second sequence is executed.
+
+The first sequence may complete in the following ways:
+
+@enumerate
+
+@item Execute the last statement in the sequence and fall off the
+end.
+
+@item Execute a goto statement (@code{GOTO_EXPR}) to an ordinary
+label outside the sequence.
+
+@item Execute a return statement (@code{RETURN_EXPR}).
+
+@item Throw an exception.  This is currently not explicitly represented in
+GIMPLE.
+
+@end enumerate
+
+The second sequence is not executed if the first sequence completes by
+calling @code{setjmp} or @code{exit} or any other function that does
+not return.  The second sequence is also not executed if the first
+sequence completes via a non-local goto or a computed goto (in general
+the compiler does not know whether such a goto statement exits the
+first sequence or not, so we assume that it doesn't).
+
+After the second sequence is executed, if it completes normally by
+falling off the end, execution continues wherever the first sequence
+would have continued, by falling off the end, or doing a goto, etc.
+
+@code{TRY_FINALLY_EXPR} complicates the flow graph, since the cleanup
+needs to appear on every edge out of the controlled block; this
+reduces the freedom to move code across these edges.  Therefore, the
+EH lowering pass which runs before most of the optimization passes
+eliminates these expressions by explicitly adding the cleanup to each
+edge.  Rethrowing the exception is represented using @code{RESX_EXPR}.
diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi
new file mode 100644 (file)
index 0000000..8277a8c
--- /dev/null
@@ -0,0 +1,2498 @@
+@c Copyright (c) 2008 Free Software Foundation, Inc.
+@c Free Software Foundation, Inc.
+@c This is part of the GCC manual.
+@c For copying conditions, see the file gcc.texi.
+
+@node GIMPLE
+@chapter GIMPLE
+@cindex 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 @code{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 @samp{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
+@code{DECL_SAVED_TREE} field of the associated @code{FUNCTION_DECL}
+tree node.  It is converted to GIMPLE by a call to
+@code{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 @code{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 @code{pass_lower_cf}.  High GIMPLE
+contains some container statements like lexical scopes
+(represented by @code{GIMPLE_BIND}) and nested expressions (e.g.,
+@code{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
+@code{_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 @code{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 @option{-fdump-tree-gimple}.
+
+@menu
+* Tuple representation::
+* GIMPLE instruction set::
+* GIMPLE Exception Handling::
+* Temporaries::
+* Operands::
+* Manipulating GIMPLE statements::
+* Tuple specific accessors::
+* GIMPLE sequences::
+* Sequence iterators::
+* Adding a new GIMPLE statement code::
+* Statement and operand traversals::
+@end menu
+
+@node Tuple representation
+@section Tuple representation
+@cindex tuples
+
+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.
+
+@subsection @code{gimple_statement_base} (gsbase)
+@cindex gimple_statement_base
+
+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:
+
+@multitable {@code{references_memory_p}} {Size (bits)}
+@item Field                            @tab Size (bits)
+@item @code{code}                      @tab 8
+@item @code{subcode}                   @tab 16
+@item @code{no_warning}                        @tab 1
+@item @code{visited}                   @tab 1
+@item @code{nontemporal_move}          @tab 1
+@item @code{plf}                       @tab 2
+@item @code{modifed}                   @tab 1
+@item @code{has_volatile_ops}          @tab 1
+@item @code{references_memory_p}       @tab 1
+@item @code{uid}                       @tab 32
+@item @code{location}                  @tab 32
+@item @code{num_ops}                   @tab 32
+@item @code{bb}                                @tab 64
+@item @code{block}                     @tab 63
+@item Total size                       @tab 32 bytes   
+@end multitable
+
+@itemize @bullet
+@item @code{code}
+Main identifier for a GIMPLE instruction. 
+
+@item @code{subcode}
+Used to distinguish different variants of the same basic
+instruction or provide flags applicable to a given code. The
+@code{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
+@code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
+
+@item @code{no_warning}
+Bitflag to indicate whether a warning has already been issued on
+this statement.
+
+@item @code{visited}
+General purpose ``visited'' marker. Set and cleared by each pass
+when needed.
+
+@item @code{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.
+
+@item @code{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.
+
+@item @code{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.
+
+@item @code{has_volatile_ops}
+Bitflag to indicate whether this statement contains operands that
+have been marked volatile.
+
+@item @code{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).
+
+@item @code{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.
+
+@item @code{location}
+This is a @code{location_t} identifier to specify source code
+location for this statement. It is inherited from the front
+end.
+
+@item @code{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.
+
+@item @code{bb}
+Basic block holding the instruction.
+@item @code{block}
+Lexical block holding this statement.  Also used for debug
+information generation.
+@end itemize
+
+@subsection @code{gimple_statement_with_ops}
+@cindex gimple_statement_with_ops
+
+This tuple is actually split in two:
+@code{gimple_statement_with_ops_base} and
+@code{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 (@code{gimple_alloc}) simply
+allocates enough memory to hold the structure itself plus @code{N
+- 1} operands which run ``off the end'' of the structure. For
+example, to allocate space for a tuple with 3 operands,
+@code{gimple_alloc} reserves @code{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 @code{gimple_statement_with_memory_ops} tuple. So, these
+common fields are placed in @code{gimple_statement_with_ops_base} which
+is then inherited from the other two tuples.
+
+
+@multitable {@code{addresses_taken}}   {56 + 8 * @code{num_ops} bytes}
+@item  @code{gsbase}           @tab 256        
+@item  @code{addresses_taken}  @tab 64 
+@item  @code{def_ops}          @tab 64 
+@item  @code{use_ops}          @tab 64 
+@item  @code{op}               @tab @code{num_ops} * 64        
+@item  Total size              @tab 56 + 8 * @code{num_ops} bytes
+@end multitable
+
+@itemize @bullet
+@item @code{gsbase}
+Inherited from @code{struct gimple_statement_base}.
+
+@item @code{addresses_taken}
+Bitmap holding the UIDs of all the @code{VAR_DECL}s whose addresses are
+taken by this statement. For example, a statement of the form
+@code{p = &b} will have the UID for symbol @code{b} in this set.
+
+@item @code{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.
+
+@item @code{use_ops}
+Similar to @code{def_ops} but for variables read by the statement.
+
+@item @code{op}
+Array of trees with @code{num_ops} slots.
+@end itemize
+
+@subsection @code{gimple_statement_with_memory_ops}
+
+This tuple is essentially identical to @code{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 accomodate for the operand
+vector (@code{gimple_statement_with_memory_ops_base} and
+@code{gimple_statement_with_memory_ops}).
+
+
+@multitable {@code{addresses_taken}}   {88 + 8 * @code{num_ops} bytes}
+@item Field                            @tab Size (bits)
+@item @code{gsbase}                    @tab 256
+@item @code{addresses_taken}           @tab 64
+@item @code{def_ops}                   @tab 64
+@item @code{use_ops}                   @tab 64
+@item @code{vdef_ops}                  @tab 64
+@item @code{vuse_ops}                  @tab 64
+@item @code{stores}                    @tab 64 
+@item @code{loads}                     @tab 64 
+@item @code{op}                                @tab @code{num_ops} * 64        
+@item Total size                       @tab 88 + 8 * @code{num_ops} bytes
+@end multitable
+
+@itemize @bullet
+@item @code{vdef_ops}
+Similar to @code{def_ops} but for @code{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.
+
+@item @code{vuse_ops}
+Similar to @code{use_ops} but for @code{VUSE} operators. There is
+one entry per memory symbol loaded by this statement. This is
+used to maintain the memory SSA use-def chains.
+
+@item @code{stores}
+Bitset with all the UIDs for the symbols written-to by the
+statement.  This is different than @code{vdef_ops} in that all the
+affected symbols are mentioned in this set.  If memory
+partitioning is enabled, the @code{vdef_ops} vector will refer to memory
+partitions. Furthermore, no SSA information is stored in this
+set.
+
+@item @code{loads}
+Similar to @code{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).
+@end itemize
+
+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 (@code{GTY} markers
+elided for clarity):
+
+@smallexample
+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;
+@};
+@end smallexample
+
+@node GIMPLE instruction set
+@section GIMPLE instruction set
+@cindex GIMPLE instruction set
+
+The following table briefly describes the GIMPLE instruction set.
+
+@multitable {@code{GIMPLE_CHANGE_DYNAMIC_TYPE}} {High GIMPLE} {Low GIMPLE}
+@item Instruction                      @tab High GIMPLE        @tab Low GIMPLE
+@item @code{GIMPLE_ASM}                        @tab x                  @tab x
+@item @code{GIMPLE_ASSIGN}             @tab x                  @tab x
+@item @code{GIMPLE_BIND}               @tab x                  @tab
+@item @code{GIMPLE_CALL}               @tab x                  @tab x
+@item @code{GIMPLE_CATCH}              @tab x                  @tab
+@item @code{GIMPLE_CHANGE_DYNAMIC_TYPE}        @tab x                  @tab x
+@item @code{GIMPLE_COND}               @tab x                  @tab x
+@item @code{GIMPLE_EH_FILTER}          @tab x                  @tab
+@item @code{GIMPLE_GOTO}               @tab x                  @tab x
+@item @code{GIMPLE_LABEL}              @tab x                  @tab x
+@item @code{GIMPLE_NOP}                        @tab x                  @tab x
+@item @code{GIMPLE_OMP_ATOMIC_LOAD}    @tab x                  @tab x
+@item @code{GIMPLE_OMP_ATOMIC_STORE}   @tab x                  @tab x
+@item @code{GIMPLE_OMP_CONTINUE}       @tab x                  @tab x
+@item @code{GIMPLE_OMP_CRITICAL}       @tab x                  @tab x
+@item @code{GIMPLE_OMP_FOR}            @tab x                  @tab x
+@item @code{GIMPLE_OMP_MASTER}         @tab x                  @tab x
+@item @code{GIMPLE_OMP_ORDERED}                @tab x                  @tab x
+@item @code{GIMPLE_OMP_PARALLEL}       @tab x                  @tab x
+@item @code{GIMPLE_OMP_RETURN}         @tab x                  @tab x
+@item @code{GIMPLE_OMP_SECTION}                @tab x                  @tab x
+@item @code{GIMPLE_OMP_SECTIONS}       @tab x                  @tab x
+@item @code{GIMPLE_OMP_SECTIONS_SWITCH}        @tab x                  @tab x
+@item @code{GIMPLE_OMP_SINGLE}         @tab x                  @tab x
+@item @code{GIMPLE_PHI}                        @tab                    @tab x
+@item @code{GIMPLE_RESX}               @tab                    @tab x
+@item @code{GIMPLE_RETURN}             @tab x                  @tab x
+@item @code{GIMPLE_SWITCH}             @tab x                  @tab x
+@item @code{GIMPLE_TRY}                        @tab x                  @tab
+@end multitable
+
+@node GIMPLE Exception Handling
+@section Exception Handling
+@cindex GIMPLE Exception Handling
+
+Other exception handling constructs are represented using
+@code{GIMPLE_TRY_CATCH}.  @code{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 @code{GIMPLE_TRY_CATCH} is checked.  The second
+operand may have the following forms:
+
+@enumerate
+
+@item A sequence of statements to execute.  When an exception occurs,
+these statements are executed, and then the exception is rethrown.
+
+@item A sequence of @code{GIMPLE_CATCH} statements.  Each
+@code{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
+@code{GIMPLE_TRY_CATCH}.
+
+@item An @code{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.
+
+@end enumerate
+
+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 @samp{goto}s, magic
+labels, and EH regions.  Continuing to unwind at the end of a
+cleanup is represented with a @code{GIMPLE_RESX}.
+
+
+@node Temporaries
+@section Temporaries
+@cindex 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 @samp{expression temporaries}, and are allocated using
+@code{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@footnote{These restrictions are derived
+from those in Morgan 4.8.}. Other temporaries can be allocated
+using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
+
+Currently, an expression like @code{a = b + 5} is not reduced any
+further.  We tried converting it to something like
+@smallexample
+  T1 = b + 5;
+  a = T1;
+@end smallexample
+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.
+
+@node Operands
+@section Operands
+@cindex 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 (@code{is_gimple_val}), i.e.@: a constant or a register
+variable.  More complex operands are factored out into temporaries, so
+that
+@smallexample
+  a = b + c + d
+@end smallexample
+becomes
+@smallexample
+  T1 = b + c;
+  a = T1 + d;
+@end smallexample
+
+The same rule holds for arguments to a @code{GIMPLE_CALL}.
+
+The target of an assignment is usually a variable, but can also be an
+@code{INDIRECT_REF} or a compound lvalue as described below.
+
+@menu
+* Compound Expressions::
+* Compound Lvalues::
+* Conditional Expressions::
+* Logical Operators::
+@end menu
+
+@node Compound Expressions
+@subsection Compound Expressions
+@cindex Compound Expressions
+
+The left-hand side of a C comma expression is simply moved into a separate
+statement.
+
+@node Compound Lvalues
+@subsection Compound Lvalues
+@cindex Compound Lvalues
+
+Currently compound lvalues involving array and structure field references
+are not broken down; an expression like @code{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
+
+@smallexample
+  T1 = &a.b;
+  T1[2] = 42;
+@end smallexample
+
+alias analysis would not remember that the reference to @code{T1[2]} came
+by way of @code{a.b}, so it would think that the assignment could alias
+another member of @code{a}; this broke @code{struct-alias-1.c}.  Future
+optimizer improvements may make this limitation unnecessary.
+
+@node Conditional Expressions
+@subsection Conditional Expressions
+@cindex Conditional Expressions
+
+A C @code{?:} expression is converted into an @code{if} statement with
+each branch assigning to the same temporary.  So,
+
+@smallexample
+  a = b ? c : d;
+@end smallexample
+becomes
+@smallexample
+  if (b == 1)
+    T1 = c;
+  else
+    T1 = d;
+  a = T1;
+@end smallexample
+
+The GIMPLE level if-conversion pass re-introduces @code{?:}
+expression, if appropriate. It is used to vectorize loops with
+conditions using vector conditional operations.
+
+Note that in GIMPLE, @code{if} statements are represented using
+@code{GIMPLE_COND}, as described below.
+
+@node Logical Operators
+@subsection Logical Operators
+@cindex Logical Operators
+
+Except when they appear in the condition operand of a
+@code{GIMPLE_COND}, logical `and' and `or' operators are simplified
+as follows: @code{a = b && c} becomes
+
+@smallexample
+  T1 = (bool)b;
+  if (T1 == true)
+    T1 = (bool)c;
+  a = T1;
+@end smallexample
+
+Note that @code{T1} in this example cannot be an expression temporary,
+because it has two different assignments.
+
+@subsection Manipulating operands
+
+All gimple operands are of type @code{tree}.  But only certain
+types of trees are allowed to be used as operand tuples.  Basic
+validation is controlled by the function
+@code{get_gimple_rhs_class}, which given a tree code, returns an
+@code{enum} with the following values of type @code{enum
+gimple_rhs_class}
+
+@itemize @bullet
+@item @code{GIMPLE_INVALID_RHS}
+The tree cannot be used as a GIMPLE operand.
+
+@item @code{GIMPLE_BINARY_RHS}
+The tree is a valid GIMPLE binary operation.
+
+@item @code{GIMPLE_UNARY_RHS}
+The tree is a valid GIMPLE unary operation.
+
+@item @code{GIMPLE_SINGLE_RHS}
+The tree is a single object, that cannot be split into simpler
+operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{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 @code{COND_EXPR}
+expression of the form @code{(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 @code{c = a op b}
+from @code{c = a op b ? x : y}.  Something similar occurs with
+@code{ASSERT_EXPR}.   In time, these special case tree
+expressions should be flattened into the operand vector.
+@end itemize
+
+For tree nodes in the categories @code{GIMPLE_BINARY_RHS} and
+@code{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
+
+@smallexample
+a = b + c
+@end smallexample
+
+its tree representation is:
+
+@smallexample
+MODIFY_EXPR <VAR_DECL  <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>
+@end smallexample
+
+In this case, the GIMPLE form for this statement is logically
+identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
+on the RHS of the assignment is not represented as a tree,
+instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree
+and flattened into the GIMPLE tuple as follows:
+
+@smallexample
+GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>
+@end smallexample
+
+@subsection 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
+
+@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
+Returns the number of operands in statement G.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
+Returns operand @code{I} from statement @code{G}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
+Returns a pointer into the operand vector for statement @code{G}.  This
+is computed using an internal table called @code{gimple_ops_offset_}[].
+This table is indexed by the gimple code of @code{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 @code{C} the offset is computed as sizeof
+(struct-of @code{C}) - sizeof (tree).
+
+This mechanism adds one memory indirection to every access when
+using @code{gimple_op}(), if this becomes a bottleneck, a pass can
+choose to memoize the result from @code{gimple_ops}() and use that to
+access the operands.
+@end deftypefn
+
+@subsection 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
+@code{gimple_<name>_set_...()}.  Each tuple will use one of the
+following predicates (Note, this list is not exhaustive):
+
+@deftypefn {GIMPLE function} is_gimple_operand (tree t)
+This is the most permissive of the predicates.  It essentially
+checks whether t has a @code{gimple_rhs_class} of @code{GIMPLE_SINGLE_RHS}.
+@end deftypefn
+
+
+@deftypefn {GIMPLE function} is_gimple_val (tree t)
+Returns true if t is a "GIMPLE value", which are all the
+non-addressable stack variables (variables for which
+@code{is_gimple_reg} returns true) and constants (expressions for which
+@code{is_gimple_min_invariant} returns true).
+@end deftypefn
+
+@deftypefn {GIMPLE function} is_gimple_addressable (tree t)
+Returns true if t is a symbol or memory reference whose address
+can be taken.
+@end deftypefn
+
+@deftypefn {GIMPLE function} is_gimple_asm_val (tree t)
+Similar to @code{is_gimple_val} but it also accepts hard registers.
+@end deftypefn
+
+@deftypefn {GIMPLE function} is_gimple_call_addr (tree t)
+Return true if t is a valid expression to use as the function
+called by a @code{GIMPLE_CALL}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} is_gimple_constant (tree t)
+Return true if t is a valid gimple constant.
+@end deftypefn
+
+@deftypefn {GIMPLE function} 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).
+@end deftypefn
+
+@deftypefn {GIMPLE function} is_gimple_min_invariant_address (tree t)
+Return true if t is an @code{ADDR_EXPR} that does not change once the
+program is running.
+@end deftypefn
+
+
+@subsection Statement validation
+
+@deftypefn {GIMPLE function} is_gimple_assign (gimple g)
+Return true if the code of g is @code{GIMPLE_ASSIGN}.
+@end deftypefn
+@deftypefn {GIMPLE function} is_gimple_call (gimple g)
+Return true if the code of g is @code{GIMPLE_CALL}
+@end deftypefn
+@deftypefn {GIMPLE function} gimple_assign_cast_p (gimple g)
+Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
+operation
+@end deftypefn
+
+@node Manipulating GIMPLE statements
+@section Manipulating GIMPLE statements
+@cindex Manipulating GIMPLE statements
+
+This section documents all the functions available to handle each
+of the GIMPLE instructions.
+
+@subsection Common accessors 
+The following are common accessors for gimple statements.
+
+@deftypefn {GIMPLE function} enum gimple_code gimple_code (gimple g)
+Return the code for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
+Return the basic block to which statement @code{G} belongs to.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_block (gimple g)
+Return the lexical scope block holding statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
+Return the type of the main expression computed by @code{STMT}. Return
+@code{void_type_node} if @code{STMT} computes nothing. This will only return
+something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
+@code{GIMPLE_CALL}.  For all other tuple codes, it will return
+@code{void_type_node}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} enum tree_code gimple_expr_code (gimple stmt)
+Return the tree code for the expression computed by @code{STMT}.  This
+is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
+@code{GIMPLE_COND}.  If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
+For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
+For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
+by the @code{RHS} of the assignment.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
+Set the lexical scope block of @code{G} to @code{BLOCK}.
+@end deftypefn
+@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
+Return locus information for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
+Set locus information for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
+Return true if @code{G} does not have locus information.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
+Return true if no warnings should be emitted for statement @code{STMT}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
+Set the visited status on statement @code{STMT} to @code{VISITED_P}.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
+Return the visited status on statement @code{STMT}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
+Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
+@end deftypefn
+@deftypefn {GIMPLE function} unsigned int gimple_plf (gimple stmt, enum plf_mask plf)
+Return the value of pass local flag @code{PLF} on statement @code{STMT}.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
+Return true if statement @code{G} has register or memory operands.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
+Return true if statement @code{G} has memory operands.
+@end deftypefn
+@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
+Return the number of operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
+Return the array of operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
+Return operand @code{I} for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_op_ptr (gimple g, unsigned i)
+Return a pointer to operand @code{I} for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
+Set operand @code{I} of statement @code{G} to @code{OP}.
+@end deftypefn
+@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
+Return the set of symbols that have had their address taken by
+@code{STMT}.
+@end deftypefn
+@deftypefn {GIMPLE function} struct def_optype_d *gimple_def_ops (gimple g)
+Return the set of @code{DEF} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
+Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} struct use_optype_d *gimple_use_ops (gimple g)
+Return the set of @code{USE} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
+Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} struct voptype_d *gimple_vuse_ops (gimple g)
+Return the set of @code{VUSE} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
+Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} struct voptype_d *gimple_vdef_ops (gimple g)
+Return the set of @code{VDEF} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
+Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
+Return the set of symbols loaded by statement @code{G}.  Each element of
+the set is the @code{DECL_UID} of the corresponding symbol.
+@end deftypefn
+@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
+Return the set of symbols stored by statement @code{G}.  Each element of
+the set is the @code{DECL_UID} of the corresponding symbol.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
+Return true if statement @code{G} has operands and the modified field
+has been set.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
+Return true if statement @code{STMT} contains volatile operands.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
+Return true if statement @code{STMT} contains volatile operands.
+@end deftypefn
+@deftypefn {GIMPLE function} void update_stmt (gimple s)
+Mark statement @code{S} as modified, and update it.
+@end deftypefn
+@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
+Update statement @code{S} if it has been marked modified.
+@end deftypefn
+@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
+Return a deep copy of statement @code{STMT}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gimple_copy_call_skip_args (gimple stmt, bitmap args_to_skip)
+Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
+in the positions marked by the set @code{ARGS_TO_SKIP}.
+@end deftypefn
+
+@node Tuple specific accessors
+@section Tuple specific accessors
+@cindex Tuple specific accessors
+
+@menu
+* @code{GIMPLE_ASM}::
+* @code{GIMPLE_ASSIGN}::
+* @code{GIMPLE_BIND}::
+* @code{GIMPLE_CALL}::
+* @code{GIMPLE_CATCH}::
+* @code{GIMPLE_CHANGE_DYNAMIC_TYPE}::
+* @code{GIMPLE_COND}::
+* @code{GIMPLE_EH_FILTER}::
+* @code{GIMPLE_LABEL}::
+* @code{GIMPLE_NOP}::
+* @code{GIMPLE_OMP_ATOMIC_LOAD}::
+* @code{GIMPLE_OMP_ATOMIC_STORE}::
+* @code{GIMPLE_OMP_CONTINUE}::
+* @code{GIMPLE_OMP_CRITICAL}::
+* @code{GIMPLE_OMP_FOR}::
+* @code{GIMPLE_OMP_MASTER}::
+* @code{GIMPLE_OMP_ORDERED}::
+* @code{GIMPLE_OMP_PARALLEL}::
+* @code{GIMPLE_OMP_RETURN}::
+* @code{GIMPLE_OMP_SECTION}::
+* @code{GIMPLE_OMP_SECTIONS}::
+* @code{GIMPLE_OMP_SINGLE}::
+* @code{GIMPLE_PHI}::
+* @code{GIMPLE_RESX}::
+* @code{GIMPLE_RETURN}::
+* @code{GIMPLE_SWITCH}::
+* @code{GIMPLE_TRY}::
+* @code{GIMPLE_WITH_CLEANUP_EXPR}::
+@end menu
+
+
+@node @code{GIMPLE_ASM}
+@subsection @code{GIMPLE_ASM}
+@cindex @code{GIMPLE_ASM}
+
+@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
+Build a @code{GIMPLE_ASM} statement.  This statement is used for
+building in-line assembly constructs.  @code{STRING} is the assembly
+code.  @code{NINPUT} is the number of register inputs.  @code{NOUTPUT} is the
+number of register outputs.  @code{NCLOBBERS} is the number of clobbered
+registers.  The rest of the arguments trees for each input,
+output, and clobbered registers.
+@end deftypefn
+
+@deftypefn {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.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_asm_ninputs (gimple g)
+Return the number of input operands for @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_asm_noutputs (gimple g)
+Return the number of output operands for @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_asm_nclobbers (gimple g)
+Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
+Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
+Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
+Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, unsigne
+index, tree out_op)
+Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
+Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
+Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} const char *gimple_asm_string (gimple g)
+Return the string representing the assembly instruction in
+@code{GIMPLE_ASM} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
+Return true if @code{G} is an asm statement marked volatile. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
+Mark asm statement @code{G} as volatile. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
+Remove volatile marker from asm statement @code{G}. 
+@end deftypefn
+
+@node @code{GIMPLE_ASSIGN}
+@subsection @code{GIMPLE_ASSIGN}
+@cindex @code{GIMPLE_ASSIGN}
+
+@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
+Build a @code{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
+@code{gimple_build_assign_with_ops}.
+@end deftypefn
+
+
+@deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
+Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
+@code{*SEQ_P}.
+@end deftypefn
+
+@code{DST}/@code{SRC} are the destination and source respectively.  You can
+pass ungimplified trees in @code{DST} or @code{SRC}, in which
+case they will be converted to a gimple operand if necessary.
+
+This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
+
+@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1, tree op2)
+This function is similar to @code{gimple_build_assign}, but is used to
+build a @code{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
+@code{tree_code} for the right-hand side of the assignment.  Op1 and op2
+are the operands.  If op2 is null, subcode must be a @code{tree_code}
+for a unary expression.
+@end deftypefn
+
+@deftypefn {GIMPLE function} enum tree_code gimple_assign_rhs_code (gimple g)
+Return the code of the expression computed on the @code{RHS} of
+assignment statement @code{G}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} enum gimple_rhs_class gimple_assign_rhs_class (gimple g)
+Return the gimple rhs class of the code fo the expression
+computed on the rhs of assignment statment @code{G}.  This will never
+return @code{GIMPLE_INVALID_RHS}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
+Return the @code{LHS} of assignment statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_assign_lhs_ptr (gimple g)
+Return a pointer to the @code{LHS} of assignment statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
+Return the first operand on the @code{RHS} of assignment statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_assign_rhs1_ptr (gimple g)
+Return the address of the first operand on the @code{RHS} of assignment
+statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
+Return the second operand on the @code{RHS} of assignment statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
+Return the address of the second operand on the @code{RHS} of assignment
+statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
+Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
+Set @code{RHS} to be the first operand on the @code{RHS} of assignment
+statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
+Return the second operand on the @code{RHS} of assignment statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
+Return a pointer to the second operand on the @code{RHS} of assignment
+statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
+Set @code{RHS} to be the second operand on the @code{RHS} of assignment
+statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
+Return true if @code{S} is an type-cast assignment.
+@end deftypefn
+
+
+@node @code{GIMPLE_BIND}
+@subsection @code{GIMPLE_BIND}
+@cindex @code{GIMPLE_BIND}
+
+@deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
+Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
+and a body of statements in sequence @code{BODY}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
+Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
+Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
+statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
+Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
+statement @code{G}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
+Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
+Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
+Append a statement to the end of a @code{GIMPLE_BIND}'s body. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
+Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
+body.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
+Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
+@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
+Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
+statement @code{G}. 
+@end deftypefn
+
+
+@node @code{GIMPLE_CALL}
+@subsection @code{GIMPLE_CALL}
+@cindex @code{GIMPLE_CALL}
+
+@deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
+Build a @code{GIMPLE_CALL} statement to function @code{FN}.  The argument @code{FN}
+must be either a @code{FUNCTION_DECL} or a gimple call address as
+determined by @code{is_gimple_call_addr}.  @code{NARGS} are the number of
+arguments.  The rest of the arguments follow the argument @code{NARGS},
+and must be trees that are valid as rvalues in gimple (i.e., each
+operand is validated with @code{is_gimple_operand}).
+@end deftypefn
+
+
+@deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
+Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node.  The arguments and the
+function are taken from the expression directly.  This routine
+assumes that @code{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 @code{call_expr} are copied over
+to the new @code{GIMPLE_CALL}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
+Identical to @code{gimple_build_call} but the arguments are stored in a
+@code{VEC}().
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
+Return the @code{LHS} of call statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_call_lhs_ptr (gimple g)
+Return a pointer to the @code{LHS} of call statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
+Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
+Return the tree node representing the function called by call
+statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
+Set @code{FN} to be the function called by call statement @code{G}.  This has
+to be a gimple value specifying the address of the called
+function.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
+If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
+Otherwise return @code{NULL}.  This function is analogous to
+@code{get_callee_fndecl} in @code{GENERIC}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
+Set the called function to @code{FNDECL}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
+Return the type returned by call statement @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
+Return the static chain for call statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
+Set @code{CHAIN} to be the static chain for call statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_call_num_args (gimple g)
+Return the number of arguments used by call statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
+Return the argument at position @code{INDEX} for call statement @code{G}.  The
+first argument is 0.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_call_arg_ptr (gimple g, unsigned index)
+Return a pointer to the argument at position @code{INDEX} for call
+statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
+Set @code{ARG} to be the argument at position @code{INDEX} for call statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
+Mark call statement @code{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. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
+Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
+Mark @code{GIMPLE_CALL} @code{S} as being uninlinable. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
+Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
+Return true if @code{S} is a noreturn call. 
+@end deftypefn
+
+
+@node @code{GIMPLE_CATCH}
+@subsection @code{GIMPLE_CATCH}
+@cindex @code{GIMPLE_CATCH}
+
+@deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
+Build a @code{GIMPLE_CATCH} statement.  @code{TYPES} are the tree types this
+catch handles.  @code{HANDLER} is a sequence of statements with the code
+for the handler.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
+Return the types handled by @code{GIMPLE_CATCH} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_catch_types_ptr (gimple g)
+Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
+Return the GIMPLE sequence representing the body of the handler
+of @code{GIMPLE_CATCH} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
+Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
+Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}. 
+@end deftypefn
+
+@node @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
+@subsection @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
+@cindex @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
+
+@deftypefn {GIMPLE function} gimple gimple_build_cdt (tree type, tree ptr)
+Build a @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement.  @code{TYPE} is the new
+type for the location @code{PTR}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_cdt_new_type (gimple g)
+Return the new type set by @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_cdt_new_type_ptr (gimple g)
+Return a pointer to the new type set by
+@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cdt_set_new_type (gimple g, tree new_type)
+Set @code{NEW_TYPE} to be the type returned by
+@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_cdt_location (gimple g)
+Return the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
+statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_cdt_location_ptr (gimple g)
+Return a pointer to the location affected by
+@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cdt_set_location (gimple g, tree ptr)
+Set @code{PTR} to be the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
+statement @code{G}. 
+@end deftypefn
+
+
+@node @code{GIMPLE_COND}
+@subsection @code{GIMPLE_COND}
+@cindex @code{GIMPLE_COND}
+
+@deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
+Build a @code{GIMPLE_COND} statement.  @code{A} @code{GIMPLE_COND} statement compares
+@code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
+the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
+@code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
+@code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
+@end deftypefn
+
+
+@deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
+Build a @code{GIMPLE_COND} statement from the conditional expression
+tree @code{COND}.  @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} enum tree_code gimple_cond_code (gimple g)
+Return the code of the predicate computed by conditional
+statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
+Set @code{CODE} to be the predicate code for the conditional statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
+Return the @code{LHS} of the predicate computed by conditional statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
+Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
+conditional statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
+Return the @code{RHS} operand of the predicate computed by conditional
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
+Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
+conditional statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
+Return the label used by conditional statement @code{G} when its
+predicate evaluates to true. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
+Set @code{LABEL} to be the label used by conditional statement @code{G} when
+its predicate evaluates to true. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
+Set @code{LABEL} to be the label used by conditional statement @code{G} when
+its predicate evaluates to false. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
+Return the label used by conditional statement @code{G} when its
+predicate evaluates to false. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
+Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
+Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'. 
+@end deftypefn
+
+@node @code{GIMPLE_EH_FILTER}
+@subsection @code{GIMPLE_EH_FILTER}
+@cindex @code{GIMPLE_EH_FILTER}
+
+@deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
+Build a @code{GIMPLE_EH_FILTER} statement.  @code{TYPES} are the filter's
+types.  @code{FAILURE} is a sequence with the filter's failure action.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
+Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_eh_filter_types_ptr (gimple g)
+Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
+statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
+Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
+statement fails. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
+Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
+Set @code{FAILURE} to be the sequence of statements to execute on
+failure for @code{GIMPLE_EH_FILTER} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
+Return the @code{EH_FILTER_MUST_NOT_THROW} flag. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
+Set the @code{EH_FILTER_MUST_NOT_THROW} flag. 
+@end deftypefn
+
+
+@node @code{GIMPLE_LABEL}
+@subsection @code{GIMPLE_LABEL}
+@cindex @code{GIMPLE_LABEL}
+
+@deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
+Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
+label, @code{LABEL}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
+Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
+Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
+statement @code{G}. 
+@end deftypefn
+
+
+@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
+Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
+Return the destination of the unconditional jump @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
+Set @code{DEST} to be the destination of the unconditonal jump @code{G}. 
+@end deftypefn
+
+
+@node @code{GIMPLE_NOP}
+@subsection @code{GIMPLE_NOP}
+@cindex @code{GIMPLE_NOP}
+
+@deftypefn {GIMPLE function} gimple gimple_build_nop (void)
+Build a @code{GIMPLE_NOP} statement.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
+Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}. 
+@end deftypefn
+
+@node @code{GIMPLE_OMP_ATOMIC_LOAD}
+@subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
+@cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
+Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement.  @code{LHS} is the left-hand
+side of the assignment.  @code{RHS} is the right-hand side of the
+assignment.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
+Set the @code{LHS} of an atomic load. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
+Get the @code{LHS} of an atomic load. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
+Set the @code{RHS} of an atomic set. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
+Get the @code{RHS} of an atomic set. 
+@end deftypefn
+
+
+@node @code{GIMPLE_OMP_ATOMIC_STORE}
+@subsection @code{GIMPLE_OMP_ATOMIC_STORE}
+@cindex @code{GIMPLE_OMP_ATOMIC_STORE}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
+Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
+stored.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
+Set the value being stored in an atomic store. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
+Return the value being stored in an atomic store. 
+@end deftypefn
+
+@node @code{GIMPLE_OMP_CONTINUE}
+@subsection @code{GIMPLE_OMP_CONTINUE}
+@cindex @code{GIMPLE_OMP_CONTINUE}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
+Build a @code{GIMPLE_OMP_CONTINUE} statement.  @code{CONTROL_DEF} is the
+definition of the control variable.  @code{CONTROL_USE} is the use of
+the control variable.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
+Return the definition of the control variable on a
+@code{GIMPLE_OMP_CONTINUE} in @code{S}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
+Same as above, but return the pointer.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
+Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
+statement in @code{S}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
+Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
+in @code{S}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
+Same as above, but return the pointer.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
+Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
+in @code{S}.
+@end deftypefn
+
+
+@node @code{GIMPLE_OMP_CRITICAL}
+@subsection @code{GIMPLE_OMP_CRITICAL}
+@cindex @code{GIMPLE_OMP_CRITICAL}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
+Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
+statements for which only one thread can execute.  @code{NAME} is an
+optional identifier for this critical block.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
+Return the name associated with @code{OMP_CRITICAL} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_critical_name_ptr (gimple g)
+Return a pointer to the name associated with @code{OMP} critical
+statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
+Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}. 
+@end deftypefn
+
+@node @code{GIMPLE_OMP_FOR}
+@subsection @code{GIMPLE_OMP_FOR}
+@cindex @code{GIMPLE_OMP_FOR}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, tre
+clauses, tree index, tree initial, tree final, tree incr,
+gimple_seq pre_body, enum tree_code omp_for_cond)
+Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
+inside the for loop.  @code{CLAUSES}, are any of the @code{OMP} loop
+construct's clauses: private, firstprivate,  lastprivate,
+reductions, ordered, schedule, and nowait.  @code{PRE_BODY} is the
+sequence of statements that are loop invariant.  @code{INDEX} is the
+index variable.  @code{INITIAL} is the initial value of @code{INDEX}.  @code{FINAL} is
+final value of @code{INDEX}.  OMP_FOR_COND is the predicate used to
+compare @code{INDEX} and @code{FINAL}.  @code{INCR} is the increment expression.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
+Return the clauses associated with @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_for_clauses_ptr (gimple g)
+Return a pointer to the @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
+Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
+Return the index variable for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_for_index_ptr (gimple g)
+Return a pointer to the index variable for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
+Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
+Return the initial value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_for_initial_ptr (gimple g)
+Return a pointer to the initial value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
+Set @code{INTIAL} to be the initial value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
+Return the final value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_for_final_ptr (gimple g)
+turn a pointer to the final value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
+Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
+Return the increment value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_for_incr_ptr (gimple g)
+Return a pointer to the increment value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
+Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
+Return the sequence of statements to execute before the @code{OMP_FOR}
+statement @code{G} starts. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
+Set @code{PRE_BODY} to be the sequence of statements to execute before
+the @code{OMP_FOR} statement @code{G} starts.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
+Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} enum tree_code gimple_omp_for_cond (gimple g)
+Return the condition code associated with @code{OMP_FOR} @code{G}. 
+@end deftypefn
+
+
+@node @code{GIMPLE_OMP_MASTER}
+@subsection @code{GIMPLE_OMP_MASTER}
+@cindex @code{GIMPLE_OMP_MASTER}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
+Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
+statements to be executed by just the master.
+@end deftypefn
+
+
+@node @code{GIMPLE_OMP_ORDERED}
+@subsection @code{GIMPLE_OMP_ORDERED}
+@cindex @code{GIMPLE_OMP_ORDERED}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
+Build a @code{GIMPLE_OMP_ORDERED} statement.
+@end deftypefn
+
+@code{BODY} is the sequence of statements inside a loop that will
+executed in sequence.
+
+
+@node @code{GIMPLE_OMP_PARALLEL}
+@subsection @code{GIMPLE_OMP_PARALLEL}
+@cindex @code{GIMPLE_OMP_PARALLEL}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg)
+Build a @code{GIMPLE_OMP_PARALLEL} statement.
+@end deftypefn
+
+@code{BODY} is sequence of statements which are executed in parallel.
+@code{CLAUSES}, are the @code{OMP} parallel construct's clauses.  @code{CHILD_FN} is
+the function created for the parallel threads to execute.
+@code{DATA_ARG} are the shared data argument(s).
+
+@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
+Return true if @code{OMP} parallel statement @code{G} has the
+@code{GF_OMP_PARALLEL_COMBINED} flag set.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
+Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
+@code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
+Return the body for the @code{OMP} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
+Set @code{BODY} to be the body for the @code{OMP} statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
+Return the clauses associated with @code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_parallel_clauses_ptr (gimple g)
+Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
+Set @code{CLAUSES} to be the list of clauses associated with
+@code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
+Return the child function used to hold the body of @code{OMP_PARALLEL}
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_parallel_child_fn_ptr (gimple g)
+Return a pointer to the child function used to hold the body of
+@code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
+Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {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 @code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_parallel_data_arg_ptr (gimple g)
+Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
+Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt)
+Returns true when the gimple statment @code{STMT} is any of the OpenMP
+types. 
+@end deftypefn
+
+
+@node @code{GIMPLE_OMP_RETURN}
+@subsection @code{GIMPLE_OMP_RETURN}
+@cindex @code{GIMPLE_OMP_RETURN}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
+Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
+non-waiting return.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
+Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
+Return true if @code{OMP} return statement @code{G} has the
+@code{GF_OMP_RETURN_NOWAIT} flag set.
+@end deftypefn
+
+@node @code{GIMPLE_OMP_SECTION}
+@subsection @code{GIMPLE_OMP_SECTION}
+@cindex @code{GIMPLE_OMP_SECTION}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
+Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
+@end deftypefn
+
+@code{BODY} is the sequence of statements in the section.
+
+@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
+Return true if @code{OMP} section statement @code{G} has the
+@code{GF_OMP_SECTION_LAST} flag set.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
+Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
+@end deftypefn
+
+@node @code{GIMPLE_OMP_SECTIONS}
+@subsection @code{GIMPLE_OMP_SECTIONS}
+@cindex @code{GIMPLE_OMP_SECTIONS}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
+Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
+section statements.  @code{CLAUSES} are any of the @code{OMP} sections
+contsruct's clauses: private, firstprivate, lastprivate,
+reduction, and nowait.
+@end deftypefn
+
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
+Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
+Return the control variable associated with the
+@code{GIMPLE_OMP_SECTIONS} in @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree *gimple_omp_sections_control_ptr (gimple g)
+Return a pointer to the clauses associated with the
+@code{GIMPLE_OMP_SECTIONS} in @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
+Set @code{CONTROL} to be the set of clauses associated with the
+@code{GIMPLE_OMP_SECTIONS} in @code{G}.
+@end deftypefn
+@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
+Return the clauses associated with @code{OMP_SECTIONS} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_sections_clauses_ptr (gimple g)
+Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
+Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
+@code{G}. 
+@end deftypefn
+
+
+@node @code{GIMPLE_OMP_SINGLE}
+@subsection @code{GIMPLE_OMP_SINGLE}
+@cindex @code{GIMPLE_OMP_SINGLE}
+
+@deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
+Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
+statements that will be executed once.  @code{CLAUSES} are any of the
+@code{OMP} single construct's clauses: private, firstprivate,
+copyprivate, nowait.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
+Return the clauses associated with @code{OMP_SINGLE} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_omp_single_clauses_ptr (gimple g)
+Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
+Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}. 
+@end deftypefn
+
+
+@node @code{GIMPLE_PHI}
+@subsection @code{GIMPLE_PHI}
+@cindex @code{GIMPLE_PHI}
+
+@deftypefn {GIMPLE function} gimple make_phi_node (tree var, int len)
+Build a @code{PHI} node with len argument slots for variable var.
+@end deftypefn
+
+@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
+Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
+Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
+be exactly the number of incoming edges for the basic block
+holding @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
+Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree *gimple_phi_result_ptr (gimple g)
+Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
+Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} struct phi_arg_d *gimple_phi_arg (gimple g, index)
+Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
+@code{GIMPLE_PHI} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
+Set @code{PHIARG} to be the argument corresponding to incoming edge
+@code{INDEX} for @code{GIMPLE_PHI} @code{G}. 
+@end deftypefn
+
+@node @code{GIMPLE_RESX}
+@subsection @code{GIMPLE_RESX}
+@cindex @code{GIMPLE_RESX}
+
+@deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
+Build a @code{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.  @code{REGION} is the exception
+region from which control is flowing.
+@end deftypefn
+
+@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
+Return the region number for @code{GIMPLE_RESX} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
+Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}. 
+@end deftypefn
+
+@node @code{GIMPLE_RETURN}
+@subsection @code{GIMPLE_RETURN}
+@cindex @code{GIMPLE_RETURN}
+
+@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
+Build a @code{GIMPLE_RETURN} statement whose return value is retval.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
+Return the return value for @code{GIMPLE_RETURN} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
+Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}. 
+@end deftypefn
+
+@node @code{GIMPLE_SWITCH}
+@subsection @code{GIMPLE_SWITCH}
+@cindex @code{GIMPLE_SWITCH}
+
+@deftypefn {GIMPLE function} gimple gimple_build_switch ( nlabels, tree index, tree default_label, ...)
+Build a @code{GIMPLE_SWITCH} statement.  @code{NLABELS} are the number of
+labels excluding the default label.  The default label is passed
+in @code{DEFAULT_LABEL}.  The rest of the arguments are trees
+representing the labels.  Each label is a tree of code
+@code{CASE_LABEL_EXPR}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree default_label, @code{VEC}(tree,heap) *args)
+This function is an alternate way of building @code{GIMPLE_SWITCH}
+statements.  @code{INDEX} and @code{DEFAULT_LABEL} are as in
+gimple_build_switch.  @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees
+that contain the labels.
+@end deftypefn
+
+@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
+Return the number of labels associated with the switch statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, unsigned nlabels)
+Set @code{NLABELS} to be the number of labels for the switch statement
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
+Return the index variable used by the switch statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
+Set @code{INDEX} to be the index variable for switch statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
+Return the label numbered @code{INDEX}. The default label is 0, followed
+by any labels in a switch statement. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned index, tree label)
+Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
+label. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
+Return the default label for a switch statement. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, tree label)
+Set the default label for a switch statement. 
+@end deftypefn
+
+
+@node @code{GIMPLE_TRY}
+@subsection @code{GIMPLE_TRY}
+@cindex @code{GIMPLE_TRY}
+
+@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, gimple_seq cleanup, unsigned int kind)
+Build a @code{GIMPLE_TRY} statement.  @code{EVAL} is a sequence with the
+expression to evaluate.  @code{CLEANUP} is a sequence of statements to
+run at clean-up time.  @code{KIND} is the enumeration value
+@code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
+or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
+construct.
+@end deftypefn
+
+@deftypefn {GIMPLE function} enum gimple_try_flags gimple_try_kind (gimple g)
+Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
+either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
+Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
+Return the sequence of statements used as the body for @code{GIMPLE_TRY}
+@code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
+Return the sequence of statements used as the cleanup body for
+@code{GIMPLE_TRY} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
+Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
+Set @code{EVAL} to be the sequence of statements to use as the body for
+@code{GIMPLE_TRY} @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
+Set @code{CLEANUP} to be the sequence of statements to use as the
+cleanup body for @code{GIMPLE_TRY} @code{G}. 
+@end deftypefn
+
+@node @code{GIMPLE_WITH_CLEANUP_EXPR}
+@subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
+@cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
+
+@deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
+Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @code{CLEANUP} is the
+clean-up expression.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
+Return the cleanup sequence for cleanup statement @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_wce_set_canup (gimple g, gimple_seq cleanup)
+Set @code{CLEANUP} to be the cleanup sequence for @code{G}. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
+Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple. 
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
+Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple. 
+@end deftypefn
+
+
+@node GIMPLE sequences 
+@section GIMPLE sequences 
+@cindex GIMPLE sequences 
+
+GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
+used in @code{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 @code{gimple_sequence}, but are more
+commonly passed by reference to functions dealing with sequences.
+The type for a sequence pointer is @code{gimple_seq} which is the same
+as struct @code{gimple_sequence} *.  When declaring a local sequence,
+you can define a local variable of type struct @code{gimple_sequence}.
+When declaring a sequence allocated on the garbage collected
+heap, use the function @code{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.
+
+@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
+Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
+not @code{NULL}.  If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
+Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
+@code{NULL}.  If *@code{DEST} is @code{NULL}, allocate a new sequence before
+appending.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
+Perform a deep copy of sequence @code{SRC} and return the result.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
+Reverse the order of the statements in the sequence @code{SEQ}.  Return
+@code{SEQ}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
+Return the first statement in sequence @code{S}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
+Return the last statement in sequence @code{S}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
+Set the last statement in sequence @code{S} to the statement in @code{LAST}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
+Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
+Initialize sequence @code{S} to an empty sequence.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
+Allocate a new sequence in the garbage collected store and return
+it.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
+Copy the sequence @code{SRC} into the sequence @code{DEST}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
+Return true if the sequence @code{S} is empty.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
+Returns the sequence of statements in @code{BB}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
+Sets the sequence of statements in @code{BB} to @code{SEQ}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
+Determine whether @code{SEQ} contains exactly one statement.
+@end deftypefn
+
+@node Sequence iterators 
+@section Sequence iterators 
+@cindex Sequence iterators 
+
+Sequence iterators are convenience constructs for iterating
+through statements in a sequence.  Given a sequence @code{SEQ}, here is
+a typical use of gimple sequence iterators:
+
+@smallexample
+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 @code{G}.  */
+  @}
+@end smallexample
+
+Backward iterations are possible:
+
+@smallexample
+        for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
+@end smallexample
+
+Forward and backward iterations on basic blocks are possible with
+@code{gsi_start_bb} and @code{gsi_last_bb}.
+
+In the documentation below we sometimes refer to enum
+@code{gsi_iterator_update}.  The valid options for this enumeration are:
+
+@itemize @bullet
+@item @code{GSI_NEW_STMT}
+Only valid when a single statement is added.  Move the iterator to it.
+
+@item @code{GSI_SAME_STMT}
+Leave the iterator at the same statement.
+
+@item @code{GSI_CONTINUE_LINKING}
+Move iterator to whatever position is suitable for linking other
+statements in the same direction.
+@end itemize
+
+Below is a list of the functions used to manipulate and use
+statement iterators.
+
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
+Return a new iterator pointing to the sequence @code{SEQ}'s first
+statement.  If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
+Use @code{gsi_start_bb} instead when the iterator needs to always have
+the correct basic block set.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
+Return a new iterator pointing to the first statement in basic
+block @code{BB}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
+Return a new iterator initially pointing to the last statement of
+sequence @code{SEQ}.  If @code{SEQ} is empty, the iterator's basic block is
+@code{NULL}.  Use @code{gsi_last_bb} instead when the iterator needs to always
+have the correct basic block set.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
+Return a new iterator pointing to the last statement in basic
+block @code{BB}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
+Return @code{TRUE} if at the end of @code{I}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
+Return @code{TRUE} if we're one statement before the end of @code{I}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
+Advance the iterator to the next gimple statement.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
+Advance the iterator to the previous gimple statement.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
+Return the current stmt.
+@end deftypefn
+
+@deftypefn {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 @code{BB}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple *gsi_stmt_ptr (gimple_stmt_iterator *i)
+Return a pointer to the current stmt.
+@end deftypefn
+
+@deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
+Return the basic block associated with this iterator.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
+Return the sequence associated with this iterator.
+@end deftypefn
+
+@deftypefn {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 @code{REMOVE_EH_INFO} is
+true we remove the statement pointed to by iterator @code{I} from the @code{EH}
+tables.  Otherwise we do not modify the @code{EH} tables.  Generally,
+@code{REMOVE_EH_INFO} should be true when the statement is going to be
+removed from the @code{IL} and not reinserted elsewhere.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
+Links the sequence of statements @code{SEQ} before the statement pointed
+by iterator @code{I}.  @code{MODE} indicates what to do with the iterator
+after insertion (see @code{enum gsi_iterator_update} above).
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
+Links statement @code{G} before the statement pointed-to by iterator @code{I}.
+Updates iterator @code{I} according to @code{MODE}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
+Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
+@code{MODE} is as in @code{gsi_insert_after}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
+Links statement @code{G} after the statement pointed-to by iterator @code{I}.
+@code{MODE} is as in @code{gsi_insert_after}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
+Move all statements in the sequence after @code{I} to a new sequence.
+Return this new sequence.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
+Move all statements in the sequence before @code{I} to a new sequence.
+Return this new sequence.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, gimple stmt, bool update_eh_info)
+Replace the statement pointed-to by @code{I} to @code{STMT}.  If @code{UPDATE_EH_INFO}
+is true, the exception handling information of the original
+statement is moved to the new statement.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
+Insert statement @code{STMT} before the statement pointed-to by iterator
+@code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
+specifies how to update iterator @code{I} after insertion (see enum
+@code{gsi_iterator_update}).
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
+Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
+Insert statement @code{STMT} after the statement pointed-to by iterator
+@code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
+specifies how to update iterator @code{I} after insertion (see enum
+@code{gsi_iterator_update}).
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
+Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
+Finds iterator for @code{STMT}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
+Move the statement at @code{FROM} so it comes right after the statement
+at @code{TO}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
+Move the statement at @code{FROM} so it comes right before the statement
+at @code{TO}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
+Move the statement at @code{FROM} to the end of basic block @code{BB}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
+Add @code{STMT} to the pending list of edge @code{E}.  No actual insertion is
+made until a call to @code{gsi_commit_edge_inserts}() is made.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
+Add the sequence of statements in @code{SEQ} to the pending list of edge
+@code{E}.  No actual insertion is made until a call to
+@code{gsi_commit_edge_inserts}() is made.
+@end deftypefn
+
+@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
+Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}.  If a new
+block has to be created, it is returned.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
+Commit insertions pending at edge @code{E}.  If a new block is created,
+set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
+This routine will commit all pending edge insertions, creating
+any new basic blocks which are necessary.
+@end deftypefn
+
+
+@node Adding a new GIMPLE statement code
+@section Adding a new GIMPLE statement code
+@cindex Adding a new GIMPLE statement code
+
+The first step in adding a new GIMPLE statement code, is
+modifying the file @code{gimple.def}, which contains all the GIMPLE
+codes.  Then you must add a corresponding structure, and an entry
+in @code{union gimple_statement_d}, both of which are located in
+@code{gimple.h}.  This in turn, will require you to add a corresponding
+@code{GTY} tag in @code{gsstruct.def}, and code to handle this tag in
+@code{gss_for_code} which is located in @code{gimple.c}.
+
+In order for the garbage collector to know the size of the
+structure you created in @code{gimple.h}, you need to add a case to
+handle your new GIMPLE statement in @code{gimple_size} which is located
+in @code{gimple.c}.
+
+You will probably want to create a function to build the new
+gimple statement in @code{gimple.c}.  The function should be called
+@code{gimple_build_<@code{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
+@code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
+corresponding prototype in @code{gimple.h}.
+
+
+@node Statement and operand traversals
+@section Statement and operand traversals
+@cindex Statement and operand traversals
+There are two functions available for walking statements and
+sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
+accordingly, and a third function for walking the operands in a
+statement: @code{walk_gimple_op}.
+
+@deftypefn {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 @code{GSI},
+optionally using traversal state stored in @code{WI}.  If @code{WI} is @code{NULL}, no
+state is kept during the traversal.
+
+The callback @code{CALLBACK_STMT} is called.  If @code{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 @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
+called on each operand of the statement via @code{walk_gimple_op}.  If
+@code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
+operands are not scanned.
+
+The return value is that returned by the last call to
+@code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
+@end deftypefn
+
+
+@deftypefn {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 @code{STMT}.  Every
+operand is walked via @code{walk_tree} with optional state information
+in @code{WI}.
+
+@code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
+Additional parameters to @code{walk_tree} must be stored in @code{WI}.  For
+each operand @code{OP}, @code{walk_tree} is called as:
+
+@smallexample
+    walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{WI}- @code{PSET})
+@end smallexample
+
+If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
+operands are not scanned.  The return value is that returned by
+the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
+specified.
+@end deftypefn
+
+
+@deftypefn {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 @code{SEQ}
+calling @code{walk_gimple_stmt} on each one.  @code{WI} is as in
+@code{walk_gimple_stmt}.  If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
+is stopped and the value returned.  Otherwise, all the statements
+are walked and @code{NULL_TREE} returned.
+@end deftypefn
index ea3d0ab..bd0edc4 100644 (file)
@@ -8,7 +8,7 @@
 @c ---------------------------------------------------------------------
 
 @node Tree SSA
-@chapter Analysis and Optimization of GIMPLE Trees
+@chapter Analysis and Optimization of GIMPLE tuples
 @cindex Tree SSA
 @cindex Optimization infrastructure for GIMPLE
 
@@ -37,728 +37,28 @@ functions and programming constructs needed to implement optimization
 passes for GIMPLE@.
 
 @menu
-* GENERIC::             A high-level language-independent representation.
-* GIMPLE::              A lower-level factored tree representation.
-* Annotations::         Attributes for statements and variables.
-* Statement Operands::  Variables referenced by GIMPLE statements.
+* Annotations::         Attributes for variables.
+* SSA Operands::       SSA names referenced by GIMPLE statements.
 * SSA::                 Static Single Assignment representation.
 * Alias analysis::      Representing aliased loads and stores.
 @end menu
 
-@node GENERIC
-@section GENERIC
-@cindex GENERIC
-
-The purpose of GENERIC is simply to provide a language-independent way of
-representing an entire function in trees.  To this end, it was necessary to
-add a few new tree codes to the back end, but most everything was already
-there.  If you can express it with the codes in @code{gcc/tree.def}, it's
-GENERIC@.
-
-Early on, there was a great deal of debate about how to think about
-statements in a tree IL@.  In GENERIC, a statement is defined as any
-expression whose value, if any, is ignored.  A statement will always
-have @code{TREE_SIDE_EFFECTS} set (or it will be discarded), but a
-non-statement expression may also have side effects.  A
-@code{CALL_EXPR}, for instance.
-
-It would be possible for some local optimizations to work on the
-GENERIC form of a function; indeed, the adapted tree inliner works
-fine on GENERIC, but the current compiler performs inlining after
-lowering to GIMPLE (a restricted form described in the next section).
-Indeed, currently the frontends perform this lowering before handing
-off to @code{tree_rest_of_compilation}, but this seems inelegant.
-
-If necessary, a front end can use some language-dependent tree codes
-in its GENERIC representation, so long as it provides a hook for
-converting them to GIMPLE and doesn't expect them to work with any
-(hypothetical) optimizers that run before the conversion to GIMPLE@.
-The intermediate representation used while parsing C and C++ looks
-very little like GENERIC, but the C and C++ gimplifier hooks are
-perfectly happy to take it as input and spit out GIMPLE@.
-
-@node GIMPLE
-@section GIMPLE
-@cindex GIMPLE
-
-GIMPLE is a simplified subset of GENERIC for use in optimization.  The
-particular subset chosen (and the name) 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 @code{goto}; a production compiler can't afford that
-kind of restriction.
-
-GIMPLE retains much of the structure of the parse trees: lexical
-scopes are represented as containers, rather than markers.  However,
-expressions are broken down into a 3-address form, using temporary
-variables to hold intermediate values.  Also, control structures are
-lowered to gotos.
-
-In GIMPLE no container node is ever used for its value; if a
-@code{COND_EXPR} or @code{BIND_EXPR} has a value, it is stored into a
-temporary within the controlled blocks, and that temporary is used in
-place of the container.
-
-The compiler pass which lowers GENERIC to GIMPLE is referred to as the
-@samp{gimplifier}.  The gimplifier works recursively, replacing complex
-statements with sequences of simple statements.
-
-@c Currently, the only way to
-@c tell whether or not an expression is in GIMPLE form is by recursively
-@c examining it; in the future there will probably be a flag to help avoid
-@c redundant work.  FIXME FIXME
-
-@menu
-* Interfaces::
-* Temporaries::
-* GIMPLE Expressions::
-* Statements::
-* GIMPLE Example::
-* Rough GIMPLE Grammar::
-@end menu
-
-@node Interfaces
-@subsection Interfaces
-@cindex gimplification
-
-The tree representation of a function is stored in
-@code{DECL_SAVED_TREE}.  It is lowered to GIMPLE by a call to
-@code{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 @code{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 @code{pass_lower_cf}.  High GIMPLE
-still contains lexical scopes and nested expressions, while low GIMPLE
-exposes all of the implicit jumps for control expressions like
-@code{COND_EXPR}.
-
-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
-@code{_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 @code{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@.
-
-A front end which wants to use the tree optimizers (and already has
-some sort of whole-function tree representation) only needs to provide
-a definition of @code{LANG_HOOKS_GIMPLIFY_EXPR}, call
-@code{gimplify_function_tree} to lower to GIMPLE, and then hand off to
-@code{tree_rest_of_compilation} to compile and output the function.
-
-You can tell the compiler to dump a C-like representation of the GIMPLE
-form with the flag @option{-fdump-tree-gimple}.
-
-@node Temporaries
-@subsection Temporaries
-@cindex Temporaries
-
-When gimplification encounters a subexpression which 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 @samp{expression temporaries}, and are
-allocated using @code{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@footnote{These restrictions are derived from those in Morgan 4.8.}.
-Other temporaries can be allocated using
-@code{get_initialized_tmp_var} or @code{create_tmp_var}.
-
-Currently, an expression like @code{a = b + 5} is not reduced any
-further.  We tried converting it to something like
-@smallexample
-  T1 = b + 5;
-  a = T1;
-@end smallexample
-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.
-
-@node GIMPLE Expressions
-@subsection Expressions
-@cindex GIMPLE Expressions
-
-In general, expressions in GIMPLE consist of an operation and the
-appropriate number of simple operands; these operands must either be a
-GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
-variable.  More complex operands are factored out into temporaries, so
-that
-@smallexample
-  a = b + c + d
-@end smallexample
-becomes
-@smallexample
-  T1 = b + c;
-  a = T1 + d;
-@end smallexample
-
-The same rule holds for arguments to a @code{CALL_EXPR}.
-
-The target of an assignment is usually a variable, but can also be an
-@code{INDIRECT_REF} or a compound lvalue as described below.
-
-@menu
-* Compound Expressions::
-* Compound Lvalues::
-* Conditional Expressions::
-* Logical Operators::
-@end menu
-
-@node Compound Expressions
-@subsubsection Compound Expressions
-@cindex Compound Expressions
-
-The left-hand side of a C comma expression is simply moved into a separate
-statement.
-
-@node Compound Lvalues
-@subsubsection Compound Lvalues
-@cindex Compound Lvalues
-
-Currently compound lvalues involving array and structure field references
-are not broken down; an expression like @code{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
-
-@smallexample
-  T1 = &a.b;
-  T1[2] = 42;
-@end smallexample
-
-alias analysis would not remember that the reference to @code{T1[2]} came
-by way of @code{a.b}, so it would think that the assignment could alias
-another member of @code{a}; this broke @code{struct-alias-1.c}.  Future
-optimizer improvements may make this limitation unnecessary.
-
-@node Conditional Expressions
-@subsubsection Conditional Expressions
-@cindex Conditional Expressions
-
-A C @code{?:} expression is converted into an @code{if} statement with
-each branch assigning to the same temporary.  So,
-
-@smallexample
-  a = b ? c : d;
-@end smallexample
-becomes
-@smallexample
-  if (b)
-    T1 = c;
-  else
-    T1 = d;
-  a = T1;
-@end smallexample
-
-Tree level if-conversion pass re-introduces @code{?:} expression, if appropriate.
-It is used to vectorize loops with conditions using vector conditional operations.
-
-Note that in GIMPLE, @code{if} statements are also represented using
-@code{COND_EXPR}, as described below.
-
-@node Logical Operators
-@subsubsection Logical Operators
-@cindex Logical Operators
-
-Except when they appear in the condition operand of a @code{COND_EXPR},
-logical `and' and `or' operators are simplified as follows:
-@code{a = b && c} becomes
-
-@smallexample
-  T1 = (bool)b;
-  if (T1)
-    T1 = (bool)c;
-  a = T1;
-@end smallexample
-
-Note that @code{T1} in this example cannot be an expression temporary,
-because it has two different assignments.
-
-@node Statements
-@subsection Statements
-@cindex Statements
-
-Most statements will be assignment statements, represented by
-@code{MODIFY_EXPR}.  A @code{CALL_EXPR} whose value is ignored can
-also be a statement.  No other C expressions can appear at statement level;
-a reference to a volatile object is converted into a @code{MODIFY_EXPR}.
-In GIMPLE form, type of @code{MODIFY_EXPR} is not meaningful.  Instead, use type
-of LHS or RHS@.
-
-There are also several varieties of complex statements.
-
-@menu
-* Blocks::
-* Statement Sequences::
-* Empty Statements::
-* Loops::
-* Selection Statements::
-* Jumps::
-* Cleanups::
-* GIMPLE Exception Handling::
-@end menu
-
-@node Blocks
-@subsubsection Blocks
-@cindex Blocks
-
-Block scopes and the variables they declare in GENERIC and GIMPLE are
-expressed using the @code{BIND_EXPR} code, which in previous versions of
-GCC was primarily used for the C statement-expression extension.
-
-Variables in a block are collected into @code{BIND_EXPR_VARS} in
-declaration order.  Any runtime initialization is moved out of
-@code{DECL_INITIAL} and into a statement in the controlled block.  When
-gimplifying from C or C++, this initialization replaces the
-@code{DECL_STMT}.
-
-Variable-length arrays (VLAs) complicate this process, as their size often
-refers to variables initialized earlier in the block.  To handle this, we
-currently split the block at that point, and move the VLA into a new, inner
-@code{BIND_EXPR}.  This strategy may change in the future.
-
-@code{DECL_SAVED_TREE} for a GIMPLE function will always be a
-@code{BIND_EXPR} which contains declarations for the temporary variables
-used in the function.
-
-A C++ program will usually contain more @code{BIND_EXPR}s than there are
-syntactic blocks in the source code, since several C++ constructs have
-implicit scopes associated with them.  On the other hand, although the C++
-front end uses pseudo-scopes to handle cleanups for objects with
-destructors, these don't translate into the GIMPLE form; multiple
-declarations at the same level use the same @code{BIND_EXPR}.
-
-@node Statement Sequences
-@subsubsection Statement Sequences
-@cindex Statement Sequences
-
-Multiple statements at the same nesting level are collected into a
-@code{STATEMENT_LIST}.  Statement lists are modified and traversed
-using the interface in @samp{tree-iterator.h}.
-
-@node Empty Statements
-@subsubsection Empty Statements
-@cindex Empty Statements
-
-Whenever possible, statements with no effect are discarded.  But if they
-are nested within another construct which cannot be discarded for some
-reason, they are instead replaced with an empty statement, generated by
-@code{build_empty_stmt}.  Initially, all empty statements were shared,
-after the pattern of the Java front end, but this caused a lot of trouble in
-practice.
-
-An empty statement is represented as @code{(void)0}.
-
-@node Loops
-@subsubsection Loops
-@cindex Loops
-
-At one time loops were expressed in GIMPLE using @code{LOOP_EXPR}, but
-now they are lowered to explicit gotos.
-
-@node Selection Statements
-@subsubsection Selection Statements
-@cindex Selection Statements
-
-A simple selection statement, such as the C @code{if} statement, is
-expressed in GIMPLE using a void @code{COND_EXPR}.  If only one branch is
-used, the other is filled with an empty statement.
-
-Normally, the condition expression is reduced to a simple comparison.  If
-it is a shortcut (@code{&&} or @code{||}) expression, however, we try to
-break up the @code{if} into multiple @code{if}s so that the implied shortcut
-is taken directly, much like the transformation done by @code{do_jump} in
-the RTL expander.
-
-A @code{SWITCH_EXPR} in GIMPLE contains the condition and a
-@code{TREE_VEC} of @code{CASE_LABEL_EXPR}s describing the case values
-and corresponding @code{LABEL_DECL}s to jump to.  The body of the
-@code{switch} is moved after the @code{SWITCH_EXPR}.
-
-@node Jumps
-@subsubsection Jumps
-@cindex Jumps
-
-Other jumps are expressed by either @code{GOTO_EXPR} or @code{RETURN_EXPR}.
-
-The operand of a @code{GOTO_EXPR} must be either a label or a variable
-containing the address to jump to.
-
-The operand of a @code{RETURN_EXPR} is either @code{NULL_TREE},
-@code{RESULT_DECL}, or a @code{MODIFY_EXPR} which sets the return value.  It
-would be nice to move the @code{MODIFY_EXPR} into a separate statement, but the
-special return semantics in @code{expand_return} make that difficult.  It may
-still happen in the future, perhaps by moving most of that logic into
-@code{expand_assignment}.
-
-@node Cleanups
-@subsubsection Cleanups
-@cindex Cleanups
-
-Destructors for local C++ objects and similar dynamic cleanups are
-represented in GIMPLE by a @code{TRY_FINALLY_EXPR}.
-@code{TRY_FINALLY_EXPR} has two operands, both of which are a sequence
-of statements to execute.  The first sequence is executed.  When it
-completes the second sequence is executed.
-
-The first sequence may complete in the following ways:
-
-@enumerate
-
-@item Execute the last statement in the sequence and fall off the
-end.
-
-@item Execute a goto statement (@code{GOTO_EXPR}) to an ordinary
-label outside the sequence.
-
-@item Execute a return statement (@code{RETURN_EXPR}).
-
-@item Throw an exception.  This is currently not explicitly represented in
-GIMPLE.
-
-@end enumerate
-
-The second sequence is not executed if the first sequence completes by
-calling @code{setjmp} or @code{exit} or any other function that does
-not return.  The second sequence is also not executed if the first
-sequence completes via a non-local goto or a computed goto (in general
-the compiler does not know whether such a goto statement exits the
-first sequence or not, so we assume that it doesn't).
-
-After the second sequence is executed, if it completes normally by
-falling off the end, execution continues wherever the first sequence
-would have continued, by falling off the end, or doing a goto, etc.
-
-@code{TRY_FINALLY_EXPR} complicates the flow graph, since the cleanup
-needs to appear on every edge out of the controlled block; this
-reduces the freedom to move code across these edges.  Therefore, the
-EH lowering pass which runs before most of the optimization passes
-eliminates these expressions by explicitly adding the cleanup to each
-edge.  Rethrowing the exception is represented using @code{RESX_EXPR}.
-
-
-@node GIMPLE Exception Handling
-@subsubsection Exception Handling
-@cindex GIMPLE Exception Handling
-
-Other exception handling constructs are represented using
-@code{TRY_CATCH_EXPR}.  @code{TRY_CATCH_EXPR} 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 @code{TRY_CATCH_EXPR} is checked.  The second operand
-may have the following forms:
-
-@enumerate
-
-@item A sequence of statements to execute.  When an exception occurs,
-these statements are executed, and then the exception is rethrown.
-
-@item A sequence of @code{CATCH_EXPR} expressions.  Each @code{CATCH_EXPR}
-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 @code{TRY_CATCH_EXPR}.
-
-@item An @code{EH_FILTER_EXPR} expression.  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.
-
-@end enumerate
-
-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 @samp{goto}s, magic labels, and EH
-regions.  Continuing to unwind at the end of a cleanup is represented
-with a @code{RESX_EXPR}.
-
-@node GIMPLE Example
-@subsection GIMPLE Example
-@cindex GIMPLE Example
-
-@smallexample
-struct A @{ A(); ~A(); @};
-
-int i;
-int g();
-void f()
-@{
-  A a;
-  int j = (--i, i ? 0 : 1);
-
-  for (int x = 42; x > 0; --x)
-    @{
-      i += g()*4 + 32;
-    @}
-@}
-@end smallexample
-
-becomes
-
-@smallexample
-void f()
-@{
-  int i.0;
-  int T.1;
-  int iftmp.2;
-  int T.3;
-  int T.4;
-  int T.5;
-  int T.6;
-
-  @{
-    struct A a;
-    int j;
-
-    __comp_ctor (&a);
-    try
-      @{
-        i.0 = i;
-        T.1 = i.0 - 1;
-        i = T.1;
-        i.0 = i;
-        if (i.0 == 0)
-          iftmp.2 = 1;
-        else
-          iftmp.2 = 0;
-        j = iftmp.2;
-        @{
-          int x;
-
-          x = 42;
-          goto test;
-          loop:;
-
-          T.3 = g ();
-          T.4 = T.3 * 4;
-          i.0 = i;
-          T.5 = T.4 + i.0;
-          T.6 = T.5 + 32;
-          i = T.6;
-          x = x - 1;
-
-          test:;
-          if (x > 0)
-            goto loop;
-          else
-            goto break_;
-          break_:;
-        @}
-      @}
-    finally
-      @{
-        __comp_dtor (&a);
-      @}
-  @}
-@}
-@end smallexample
-
-@node Rough GIMPLE Grammar
-@subsection Rough GIMPLE Grammar
-@cindex Rough GIMPLE Grammar
-
-@smallexample
-   function     : FUNCTION_DECL
-                        DECL_SAVED_TREE -> compound-stmt
-
-   compound-stmt: STATEMENT_LIST
-                        members -> stmt
-
-   stmt         : block
-                | if-stmt
-                | switch-stmt
-                | goto-stmt
-                | return-stmt
-                | resx-stmt
-                | label-stmt
-                | try-stmt
-                | modify-stmt
-                | call-stmt
-
-   block        : BIND_EXPR
-                        BIND_EXPR_VARS -> chain of DECLs
-                        BIND_EXPR_BLOCK -> BLOCK
-                        BIND_EXPR_BODY -> compound-stmt
-
-   if-stmt      : COND_EXPR
-                        op0 -> condition
-                        op1 -> compound-stmt
-                        op2 -> compound-stmt
-
-   switch-stmt  : SWITCH_EXPR
-                        op0 -> val
-                        op1 -> NULL
-                        op2 -> TREE_VEC of CASE_LABEL_EXPRs
-                            The CASE_LABEL_EXPRs are sorted by CASE_LOW,
-                            and default is last.
-
-   goto-stmt    : GOTO_EXPR
-                        op0 -> LABEL_DECL | val
-
-   return-stmt  : RETURN_EXPR
-                        op0 -> return-value
-
-   return-value : NULL
-                | RESULT_DECL
-                | MODIFY_EXPR
-                        op0 -> RESULT_DECL
-                        op1 -> lhs
-
-   resx-stmt    : RESX_EXPR
-
-   label-stmt   : LABEL_EXPR
-                        op0 -> LABEL_DECL
-
-   try-stmt     : TRY_CATCH_EXPR
-                        op0 -> compound-stmt
-                        op1 -> handler
-                | TRY_FINALLY_EXPR
-                        op0 -> compound-stmt
-                        op1 -> compound-stmt
-
-   handler      : catch-seq
-                | EH_FILTER_EXPR
-                | compound-stmt
-
-   catch-seq    : STATEMENT_LIST
-                        members -> CATCH_EXPR
-
-   modify-stmt  : MODIFY_EXPR
-                        op0 -> lhs
-                        op1 -> rhs
-
-   call-stmt    : CALL_EXPR
-                        op0 -> val | OBJ_TYPE_REF
-                        op1 -> call-arg-list
-
-   call-arg-list: TREE_LIST
-                        members -> lhs | CONST
-
-   addr-expr-arg: ID
-                | compref
-
-   addressable  : addr-expr-arg
-                | indirectref
-
-   with-size-arg: addressable
-                | call-stmt
-
-   indirectref  : INDIRECT_REF
-                        op0 -> val
-
-   lhs          : addressable
-                | bitfieldref
-                | WITH_SIZE_EXPR
-                        op0 -> with-size-arg
-                        op1 -> val
-
-   min-lval     : ID
-                | indirectref
-
-   bitfieldref  : BIT_FIELD_REF
-                        op0 -> inner-compref
-                        op1 -> CONST
-                        op2 -> val
-
-   compref      : inner-compref
-                | TARGET_MEM_REF
-                        op0 -> ID
-                        op1 -> val
-                        op2 -> val
-                        op3 -> CONST
-                        op4 -> CONST
-                | REALPART_EXPR
-                        op0 -> inner-compref
-                | IMAGPART_EXPR
-                        op0 -> inner-compref
-
-   inner-compref: min-lval
-                | COMPONENT_REF
-                        op0 -> inner-compref
-                        op1 -> FIELD_DECL
-                        op2 -> val
-                | ARRAY_REF
-                        op0 -> inner-compref
-                        op1 -> val
-                        op2 -> val
-                        op3 -> val
-                | ARRAY_RANGE_REF
-                        op0 -> inner-compref
-                        op1 -> val
-                        op2 -> val
-                        op3 -> val
-                | VIEW_CONVERT_EXPR
-                        op0 -> inner-compref
-
-   condition    : val
-                | RELOP
-                        op0 -> val
-                        op1 -> val
-
-   val          : ID
-                | invariant ADDR_EXPR
-                        op0 -> addr-expr-arg
-                | CONST
-
-   rhs          : lhs
-                | CONST
-                | call-stmt
-                | ADDR_EXPR
-                        op0 -> addr-expr-arg
-                | UNOP
-                        op0 -> val
-                | BINOP
-                        op0 -> val
-                        op1 -> val
-                | RELOP
-                        op0 -> val
-                        op1 -> val
-                | COND_EXPR
-                        op0 -> condition
-                        op1 -> val
-                        op2 -> val
-@end smallexample
-
 @node Annotations
 @section Annotations
 @cindex annotations
 
-The optimizers need to associate attributes with statements and
-variables during the optimization process.  For instance, we need to
-know what basic block a statement belongs to or whether a variable
-has aliases.  All these attributes are stored in data structures
-called annotations which are then linked to the field @code{ann} in
-@code{struct tree_common}.
+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
+@code{ann} in @code{struct tree_common}.
 
-Presently, we define annotations for statements (@code{stmt_ann_t}),
-variables (@code{var_ann_t}) and SSA names (@code{ssa_name_ann_t}).
+Presently, we define annotations for variables (@code{var_ann_t}).
 Annotations are defined and documented in @file{tree-flow.h}.
 
 
-@node Statement Operands
-@section Statement Operands
+@node SSA Operands
+@section SSA Operands
 @cindex operands
 @cindex virtual operands
 @cindex real operands
index 9075b2e..f6a1450 100644 (file)
@@ -3188,9 +3188,11 @@ canonicalize_cond_expr_cond (tree t)
   return NULL_TREE;
 }
 
-/* Build call same as STMT but skipping arguments 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
-giple_copy_call_skip_args (gimple stmt, bitmap args_to_skip)
+gimple_copy_call_skip_args (gimple stmt, bitmap args_to_skip)
 {
   int i;
   tree fn = gimple_call_fn (stmt);
index 03b6217..85fc75e 100644 (file)
@@ -4479,7 +4479,7 @@ basic_block gsi_insert_on_edge_immediate (edge, gimple);
 basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
 void gsi_commit_one_edge_insert (edge, basic_block *);
 void gsi_commit_edge_inserts (void);
-gimple giple_copy_call_skip_args (gimple, bitmap);
+gimple gimple_copy_call_skip_args (gimple, bitmap);
 
 
 /* Convenience routines to walk all statements of a gimple function.
index 455ba91..87c7245 100644 (file)
@@ -967,7 +967,8 @@ ipcp_update_callgraph (void)
                current_function_decl = cs->caller->decl;
                push_cfun (DECL_STRUCT_FUNCTION (cs->caller->decl));
                
-               new_stmt = giple_copy_call_skip_args (cs->call_stmt, args_to_skip);
+               new_stmt = gimple_copy_call_skip_args (cs->call_stmt,
+                                                      args_to_skip);
                gsi = gsi_for_stmt (cs->call_stmt);
                gsi_replace (&gsi, new_stmt, true);
                cgraph_set_call_stmt (cs, new_stmt);