OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [doc/] [gimple.texi] - Diff between revs 816 and 826

Only display areas with differences | Details | Blame | View Log

Rev 816 Rev 826
@c Copyright (c) 2008, 2009, 2010 Free Software Foundation, Inc.
@c Copyright (c) 2008, 2009, 2010 Free Software Foundation, Inc.
@c Free Software Foundation, Inc.
@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@c For copying conditions, see the file gcc.texi.
 
 
@node GIMPLE
@node GIMPLE
@chapter GIMPLE
@chapter GIMPLE
@cindex GIMPLE
@cindex GIMPLE
 
 
GIMPLE is a three-address representation derived from GENERIC by
GIMPLE is a three-address representation derived from GENERIC by
breaking down GENERIC expressions into tuples of no more than 3
breaking down GENERIC expressions into tuples of no more than 3
operands (with some exceptions like function calls).  GIMPLE was
operands (with some exceptions like function calls).  GIMPLE was
heavily influenced by the SIMPLE IL used by the McCAT compiler
heavily influenced by the SIMPLE IL used by the McCAT compiler
project at McGill University, though we have made some different
project at McGill University, though we have made some different
choices.  For one thing, SIMPLE doesn't support @code{goto}.
choices.  For one thing, SIMPLE doesn't support @code{goto}.
 
 
Temporaries are introduced to hold intermediate values needed to
Temporaries are introduced to hold intermediate values needed to
compute complex expressions. Additionally, all the control
compute complex expressions. Additionally, all the control
structures used in GENERIC are lowered into conditional jumps,
structures used in GENERIC are lowered into conditional jumps,
lexical scopes are removed and exception regions are converted
lexical scopes are removed and exception regions are converted
into an on the side exception region tree.
into an on the side exception region tree.
 
 
The compiler pass which converts GENERIC into GIMPLE is referred to as
The compiler pass which converts GENERIC into GIMPLE is referred to as
the @samp{gimplifier}.  The gimplifier works recursively, generating
the @samp{gimplifier}.  The gimplifier works recursively, generating
GIMPLE tuples out of the original GENERIC expressions.
GIMPLE tuples out of the original GENERIC expressions.
 
 
One of the early implementation strategies used for the GIMPLE
One of the early implementation strategies used for the GIMPLE
representation was to use the same internal data structures used
representation was to use the same internal data structures used
by front ends to represent parse trees. This simplified
by front ends to represent parse trees. This simplified
implementation because we could leverage existing functionality
implementation because we could leverage existing functionality
and interfaces. However, GIMPLE is a much more restrictive
and interfaces. However, GIMPLE is a much more restrictive
representation than abstract syntax trees (AST), therefore it
representation than abstract syntax trees (AST), therefore it
does not require the full structural complexity provided by the
does not require the full structural complexity provided by the
main tree data structure.
main tree data structure.
 
 
The GENERIC representation of a function is stored in the
The GENERIC representation of a function is stored in the
@code{DECL_SAVED_TREE} field of the associated @code{FUNCTION_DECL}
@code{DECL_SAVED_TREE} field of the associated @code{FUNCTION_DECL}
tree node.  It is converted to GIMPLE by a call to
tree node.  It is converted to GIMPLE by a call to
@code{gimplify_function_tree}.
@code{gimplify_function_tree}.
 
 
If a front end wants to include language-specific tree codes in the 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
representation which it provides to the back end, it must provide a
definition of @code{LANG_HOOKS_GIMPLIFY_EXPR} which knows how to
definition of @code{LANG_HOOKS_GIMPLIFY_EXPR} which knows how to
convert the front end trees to GIMPLE@.  Usually such a hook will involve
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
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
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.
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
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
consists of the IL before the pass @code{pass_lower_cf}.  High GIMPLE
contains some container statements like lexical scopes
contains some container statements like lexical scopes
(represented by @code{GIMPLE_BIND}) and nested expressions (e.g.,
(represented by @code{GIMPLE_BIND}) and nested expressions (e.g.,
@code{GIMPLE_TRY}), while ``Low GIMPLE'' exposes all of the
@code{GIMPLE_TRY}), while ``Low GIMPLE'' exposes all of the
implicit jumps for control and exception expressions directly in
implicit jumps for control and exception expressions directly in
the IL and EH region trees.
the IL and EH region trees.
 
 
The C and C++ front ends currently convert directly from front end
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
trees to GIMPLE, and hand that off to the back end rather than first
converting to GENERIC@.  Their gimplifier hooks know about all the
converting to GENERIC@.  Their gimplifier hooks know about all the
@code{_STMT} nodes and how to convert them to GENERIC forms.  There
@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
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
the existence of @code{STMT_EXPR} meant that in order to convert all
of the C statements into GENERIC equivalents would involve walking the
of the C statements into GENERIC equivalents would involve walking the
entire tree anyway, so it was simpler to lower all the way.  This
entire tree anyway, so it was simpler to lower all the way.  This
might change in the future if someone writes an optimization pass
might change in the future if someone writes an optimization pass
which would work better with higher-level trees, but currently the
which would work better with higher-level trees, but currently the
optimizers all expect GIMPLE@.
optimizers all expect GIMPLE@.
 
 
You can request to dump a C-like representation of the GIMPLE form
You can request to dump a C-like representation of the GIMPLE form
with the flag @option{-fdump-tree-gimple}.
with the flag @option{-fdump-tree-gimple}.
 
 
@menu
@menu
* Tuple representation::
* Tuple representation::
* GIMPLE instruction set::
* GIMPLE instruction set::
* GIMPLE Exception Handling::
* GIMPLE Exception Handling::
* Temporaries::
* Temporaries::
* Operands::
* Operands::
* Manipulating GIMPLE statements::
* Manipulating GIMPLE statements::
* Tuple specific accessors::
* Tuple specific accessors::
* GIMPLE sequences::
* GIMPLE sequences::
* Sequence iterators::
* Sequence iterators::
* Adding a new GIMPLE statement code::
* Adding a new GIMPLE statement code::
* Statement and operand traversals::
* Statement and operand traversals::
@end menu
@end menu
 
 
@node Tuple representation
@node Tuple representation
@section Tuple representation
@section Tuple representation
@cindex tuples
@cindex tuples
 
 
GIMPLE instructions are tuples of variable size divided in two
GIMPLE instructions are tuples of variable size divided in two
groups: a header describing the instruction and its locations,
groups: a header describing the instruction and its locations,
and a variable length body with all the operands. Tuples are
and a variable length body with all the operands. Tuples are
organized into a hierarchy with 3 main classes of tuples.
organized into a hierarchy with 3 main classes of tuples.
 
 
@subsection @code{gimple_statement_base} (gsbase)
@subsection @code{gimple_statement_base} (gsbase)
@cindex gimple_statement_base
@cindex gimple_statement_base
 
 
This is the root of the hierarchy, it holds basic information
This is the root of the hierarchy, it holds basic information
needed by most GIMPLE statements. There are some fields that
needed by most GIMPLE statements. There are some fields that
may not be relevant to every GIMPLE statement, but those were
may not be relevant to every GIMPLE statement, but those were
moved into the base structure to take advantage of holes left by
moved into the base structure to take advantage of holes left by
other fields (thus making the structure more compact).  The
other fields (thus making the structure more compact).  The
structure takes 4 words (32 bytes) on 64 bit hosts:
structure takes 4 words (32 bytes) on 64 bit hosts:
 
 
@multitable {@code{references_memory_p}} {Size (bits)}
@multitable {@code{references_memory_p}} {Size (bits)}
@item Field                             @tab Size (bits)
@item Field                             @tab Size (bits)
@item @code{code}                       @tab 8
@item @code{code}                       @tab 8
@item @code{subcode}                    @tab 16
@item @code{subcode}                    @tab 16
@item @code{no_warning}                 @tab 1
@item @code{no_warning}                 @tab 1
@item @code{visited}                    @tab 1
@item @code{visited}                    @tab 1
@item @code{nontemporal_move}           @tab 1
@item @code{nontemporal_move}           @tab 1
@item @code{plf}                        @tab 2
@item @code{plf}                        @tab 2
@item @code{modified}                   @tab 1
@item @code{modified}                   @tab 1
@item @code{has_volatile_ops}           @tab 1
@item @code{has_volatile_ops}           @tab 1
@item @code{references_memory_p}        @tab 1
@item @code{references_memory_p}        @tab 1
@item @code{uid}                        @tab 32
@item @code{uid}                        @tab 32
@item @code{location}                   @tab 32
@item @code{location}                   @tab 32
@item @code{num_ops}                    @tab 32
@item @code{num_ops}                    @tab 32
@item @code{bb}                         @tab 64
@item @code{bb}                         @tab 64
@item @code{block}                      @tab 63
@item @code{block}                      @tab 63
@item Total size                        @tab 32 bytes
@item Total size                        @tab 32 bytes
@end multitable
@end multitable
 
 
@itemize @bullet
@itemize @bullet
@item @code{code}
@item @code{code}
Main identifier for a GIMPLE instruction.
Main identifier for a GIMPLE instruction.
 
 
@item @code{subcode}
@item @code{subcode}
Used to distinguish different variants of the same basic
Used to distinguish different variants of the same basic
instruction or provide flags applicable to a given code. The
instruction or provide flags applicable to a given code. The
@code{subcode} flags field has different uses depending on the code of
@code{subcode} flags field has different uses depending on the code of
the instruction, but mostly it distinguishes instructions of the
the instruction, but mostly it distinguishes instructions of the
same family. The most prominent use of this field is in
same family. The most prominent use of this field is in
assignments, where subcode indicates the operation done on the
assignments, where subcode indicates the operation done on the
RHS of the assignment. For example, a = b + c is encoded as
RHS of the assignment. For example, a = b + c is encoded as
@code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
@code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
 
 
@item @code{no_warning}
@item @code{no_warning}
Bitflag to indicate whether a warning has already been issued on
Bitflag to indicate whether a warning has already been issued on
this statement.
this statement.
 
 
@item @code{visited}
@item @code{visited}
General purpose ``visited'' marker. Set and cleared by each pass
General purpose ``visited'' marker. Set and cleared by each pass
when needed.
when needed.
 
 
@item @code{nontemporal_move}
@item @code{nontemporal_move}
Bitflag used in assignments that represent non-temporal moves.
Bitflag used in assignments that represent non-temporal moves.
Although this bitflag is only used in assignments, it was moved
Although this bitflag is only used in assignments, it was moved
into the base to take advantage of the bit holes left by the
into the base to take advantage of the bit holes left by the
previous fields.
previous fields.
 
 
@item @code{plf}
@item @code{plf}
Pass Local Flags. This 2-bit mask can be used as general purpose
Pass Local Flags. This 2-bit mask can be used as general purpose
markers by any pass. Passes are responsible for clearing and
markers by any pass. Passes are responsible for clearing and
setting these two flags accordingly.
setting these two flags accordingly.
 
 
@item @code{modified}
@item @code{modified}
Bitflag to indicate whether the statement has been modified.
Bitflag to indicate whether the statement has been modified.
Used mainly by the operand scanner to determine when to re-scan a
Used mainly by the operand scanner to determine when to re-scan a
statement for operands.
statement for operands.
 
 
@item @code{has_volatile_ops}
@item @code{has_volatile_ops}
Bitflag to indicate whether this statement contains operands that
Bitflag to indicate whether this statement contains operands that
have been marked volatile.
have been marked volatile.
 
 
@item @code{references_memory_p}
@item @code{references_memory_p}
Bitflag to indicate whether this statement contains memory
Bitflag to indicate whether this statement contains memory
references (i.e., its operands are either global variables, or
references (i.e., its operands are either global variables, or
pointer dereferences or anything that must reside in memory).
pointer dereferences or anything that must reside in memory).
 
 
@item @code{uid}
@item @code{uid}
This is an unsigned integer used by passes that want to assign
This is an unsigned integer used by passes that want to assign
IDs to every statement. These IDs must be assigned and used by
IDs to every statement. These IDs must be assigned and used by
each pass.
each pass.
 
 
@item @code{location}
@item @code{location}
This is a @code{location_t} identifier to specify source code
This is a @code{location_t} identifier to specify source code
location for this statement. It is inherited from the front
location for this statement. It is inherited from the front
end.
end.
 
 
@item @code{num_ops}
@item @code{num_ops}
Number of operands that this statement has. This specifies the
Number of operands that this statement has. This specifies the
size of the operand vector embedded in the tuple. Only used in
size of the operand vector embedded in the tuple. Only used in
some tuples, but it is declared in the base tuple to take
some tuples, but it is declared in the base tuple to take
advantage of the 32-bit hole left by the previous fields.
advantage of the 32-bit hole left by the previous fields.
 
 
@item @code{bb}
@item @code{bb}
Basic block holding the instruction.
Basic block holding the instruction.
 
 
@item @code{block}
@item @code{block}
Lexical block holding this statement.  Also used for debug
Lexical block holding this statement.  Also used for debug
information generation.
information generation.
@end itemize
@end itemize
 
 
@subsection @code{gimple_statement_with_ops}
@subsection @code{gimple_statement_with_ops}
@cindex gimple_statement_with_ops
@cindex gimple_statement_with_ops
 
 
This tuple is actually split in two:
This tuple is actually split in two:
@code{gimple_statement_with_ops_base} and
@code{gimple_statement_with_ops_base} and
@code{gimple_statement_with_ops}. This is needed to accommodate the
@code{gimple_statement_with_ops}. This is needed to accommodate the
way the operand vector is allocated. The operand vector is
way the operand vector is allocated. The operand vector is
defined to be an array of 1 element. So, to allocate a dynamic
defined to be an array of 1 element. So, to allocate a dynamic
number of operands, the memory allocator (@code{gimple_alloc}) simply
number of operands, the memory allocator (@code{gimple_alloc}) simply
allocates enough memory to hold the structure itself plus @code{N
allocates enough memory to hold the structure itself plus @code{N
- 1} operands which run ``off the end'' of the structure. For
- 1} operands which run ``off the end'' of the structure. For
example, to allocate space for a tuple with 3 operands,
example, to allocate space for a tuple with 3 operands,
@code{gimple_alloc} reserves @code{sizeof (struct
@code{gimple_alloc} reserves @code{sizeof (struct
gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
 
 
On the other hand, several fields in this tuple need to be shared
On the other hand, several fields in this tuple need to be shared
with the @code{gimple_statement_with_memory_ops} tuple. So, these
with the @code{gimple_statement_with_memory_ops} tuple. So, these
common fields are placed in @code{gimple_statement_with_ops_base} which
common fields are placed in @code{gimple_statement_with_ops_base} which
is then inherited from the other two tuples.
is then inherited from the other two tuples.
 
 
 
 
@multitable {@code{addresses_taken}}    {56 + 8 * @code{num_ops} bytes}
@multitable {@code{addresses_taken}}    {56 + 8 * @code{num_ops} bytes}
@item   @code{gsbase}           @tab 256
@item   @code{gsbase}           @tab 256
@item   @code{addresses_taken}  @tab 64
@item   @code{addresses_taken}  @tab 64
@item   @code{def_ops}          @tab 64
@item   @code{def_ops}          @tab 64
@item   @code{use_ops}          @tab 64
@item   @code{use_ops}          @tab 64
@item   @code{op}               @tab @code{num_ops} * 64
@item   @code{op}               @tab @code{num_ops} * 64
@item   Total size              @tab 56 + 8 * @code{num_ops} bytes
@item   Total size              @tab 56 + 8 * @code{num_ops} bytes
@end multitable
@end multitable
 
 
@itemize @bullet
@itemize @bullet
@item @code{gsbase}
@item @code{gsbase}
Inherited from @code{struct gimple_statement_base}.
Inherited from @code{struct gimple_statement_base}.
 
 
@item @code{addresses_taken}
@item @code{addresses_taken}
Bitmap holding the UIDs of all the @code{VAR_DECL}s whose addresses are
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
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.
@code{p = &b} will have the UID for symbol @code{b} in this set.
 
 
@item @code{def_ops}
@item @code{def_ops}
Array of pointers into the operand array indicating all the slots that
Array of pointers into the operand array indicating all the slots that
contain a variable written-to by the statement. This array is
contain a variable written-to by the statement. This array is
also used for immediate use chaining. Note that it would be
also used for immediate use chaining. Note that it would be
possible to not rely on this array, but the changes required to
possible to not rely on this array, but the changes required to
implement this are pretty invasive.
implement this are pretty invasive.
 
 
@item @code{use_ops}
@item @code{use_ops}
Similar to @code{def_ops} but for variables read by the statement.
Similar to @code{def_ops} but for variables read by the statement.
 
 
@item @code{op}
@item @code{op}
Array of trees with @code{num_ops} slots.
Array of trees with @code{num_ops} slots.
@end itemize
@end itemize
 
 
@subsection @code{gimple_statement_with_memory_ops}
@subsection @code{gimple_statement_with_memory_ops}
 
 
This tuple is essentially identical to @code{gimple_statement_with_ops},
This tuple is essentially identical to @code{gimple_statement_with_ops},
except that it contains 4 additional fields to hold vectors
except that it contains 4 additional fields to hold vectors
related memory stores and loads.  Similar to the previous case,
related memory stores and loads.  Similar to the previous case,
the structure is split in two to accommodate for the operand
the structure is split in two to accommodate for the operand
vector (@code{gimple_statement_with_memory_ops_base} and
vector (@code{gimple_statement_with_memory_ops_base} and
@code{gimple_statement_with_memory_ops}).
@code{gimple_statement_with_memory_ops}).
 
 
 
 
@multitable {@code{addresses_taken}}    {88 + 8 * @code{num_ops} bytes}
@multitable {@code{addresses_taken}}    {88 + 8 * @code{num_ops} bytes}
@item Field                             @tab Size (bits)
@item Field                             @tab Size (bits)
@item @code{gsbase}                     @tab 256
@item @code{gsbase}                     @tab 256
@item @code{addresses_taken}            @tab 64
@item @code{addresses_taken}            @tab 64
@item @code{def_ops}                    @tab 64
@item @code{def_ops}                    @tab 64
@item @code{use_ops}                    @tab 64
@item @code{use_ops}                    @tab 64
@item @code{vdef_ops}                   @tab 64
@item @code{vdef_ops}                   @tab 64
@item @code{vuse_ops}                   @tab 64
@item @code{vuse_ops}                   @tab 64
@item @code{stores}                     @tab 64
@item @code{stores}                     @tab 64
@item @code{loads}                      @tab 64
@item @code{loads}                      @tab 64
@item @code{op}                         @tab @code{num_ops} * 64
@item @code{op}                         @tab @code{num_ops} * 64
@item Total size                        @tab 88 + 8 * @code{num_ops} bytes
@item Total size                        @tab 88 + 8 * @code{num_ops} bytes
@end multitable
@end multitable
 
 
@itemize @bullet
@itemize @bullet
@item @code{vdef_ops}
@item @code{vdef_ops}
Similar to @code{def_ops} but for @code{VDEF} operators. There is
Similar to @code{def_ops} but for @code{VDEF} operators. There is
one entry per memory symbol written by this statement. This is
one entry per memory symbol written by this statement. This is
used to maintain the memory SSA use-def and def-def chains.
used to maintain the memory SSA use-def and def-def chains.
 
 
@item @code{vuse_ops}
@item @code{vuse_ops}
Similar to @code{use_ops} but for @code{VUSE} operators. There is
Similar to @code{use_ops} but for @code{VUSE} operators. There is
one entry per memory symbol loaded by this statement. This is
one entry per memory symbol loaded by this statement. This is
used to maintain the memory SSA use-def chains.
used to maintain the memory SSA use-def chains.
 
 
@item @code{stores}
@item @code{stores}
Bitset with all the UIDs for the symbols written-to by the
Bitset with all the UIDs for the symbols written-to by the
statement.  This is different than @code{vdef_ops} in that all the
statement.  This is different than @code{vdef_ops} in that all the
affected symbols are mentioned in this set.  If memory
affected symbols are mentioned in this set.  If memory
partitioning is enabled, the @code{vdef_ops} vector will refer to memory
partitioning is enabled, the @code{vdef_ops} vector will refer to memory
partitions. Furthermore, no SSA information is stored in this
partitions. Furthermore, no SSA information is stored in this
set.
set.
 
 
@item @code{loads}
@item @code{loads}
Similar to @code{stores}, but for memory loads. (Note that there
Similar to @code{stores}, but for memory loads. (Note that there
is some amount of redundancy here, it should be possible to
is some amount of redundancy here, it should be possible to
reduce memory utilization further by removing these sets).
reduce memory utilization further by removing these sets).
@end itemize
@end itemize
 
 
All the other tuples are defined in terms of these three basic
All the other tuples are defined in terms of these three basic
ones. Each tuple will add some fields. The main gimple type
ones. Each tuple will add some fields. The main gimple type
is defined to be the union of all these structures (@code{GTY} markers
is defined to be the union of all these structures (@code{GTY} markers
elided for clarity):
elided for clarity):
 
 
@smallexample
@smallexample
union gimple_statement_d
union gimple_statement_d
@{
@{
  struct gimple_statement_base gsbase;
  struct gimple_statement_base gsbase;
  struct gimple_statement_with_ops gsops;
  struct gimple_statement_with_ops gsops;
  struct gimple_statement_with_memory_ops gsmem;
  struct gimple_statement_with_memory_ops gsmem;
  struct gimple_statement_omp omp;
  struct gimple_statement_omp omp;
  struct gimple_statement_bind gimple_bind;
  struct gimple_statement_bind gimple_bind;
  struct gimple_statement_catch gimple_catch;
  struct gimple_statement_catch gimple_catch;
  struct gimple_statement_eh_filter gimple_eh_filter;
  struct gimple_statement_eh_filter gimple_eh_filter;
  struct gimple_statement_phi gimple_phi;
  struct gimple_statement_phi gimple_phi;
  struct gimple_statement_resx gimple_resx;
  struct gimple_statement_resx gimple_resx;
  struct gimple_statement_try gimple_try;
  struct gimple_statement_try gimple_try;
  struct gimple_statement_wce gimple_wce;
  struct gimple_statement_wce gimple_wce;
  struct gimple_statement_asm gimple_asm;
  struct gimple_statement_asm gimple_asm;
  struct gimple_statement_omp_critical gimple_omp_critical;
  struct gimple_statement_omp_critical gimple_omp_critical;
  struct gimple_statement_omp_for gimple_omp_for;
  struct gimple_statement_omp_for gimple_omp_for;
  struct gimple_statement_omp_parallel gimple_omp_parallel;
  struct gimple_statement_omp_parallel gimple_omp_parallel;
  struct gimple_statement_omp_task gimple_omp_task;
  struct gimple_statement_omp_task gimple_omp_task;
  struct gimple_statement_omp_sections gimple_omp_sections;
  struct gimple_statement_omp_sections gimple_omp_sections;
  struct gimple_statement_omp_single gimple_omp_single;
  struct gimple_statement_omp_single gimple_omp_single;
  struct gimple_statement_omp_continue gimple_omp_continue;
  struct gimple_statement_omp_continue gimple_omp_continue;
  struct gimple_statement_omp_atomic_load gimple_omp_atomic_load;
  struct gimple_statement_omp_atomic_load gimple_omp_atomic_load;
  struct gimple_statement_omp_atomic_store gimple_omp_atomic_store;
  struct gimple_statement_omp_atomic_store gimple_omp_atomic_store;
@};
@};
@end smallexample
@end smallexample
 
 
 
 
@node GIMPLE instruction set
@node GIMPLE instruction set
@section GIMPLE instruction set
@section GIMPLE instruction set
@cindex GIMPLE instruction set
@cindex GIMPLE instruction set
 
 
The following table briefly describes the GIMPLE instruction set.
The following table briefly describes the GIMPLE instruction set.
 
 
@multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE}
@multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE}
@item Instruction                       @tab High GIMPLE        @tab Low GIMPLE
@item Instruction                       @tab High GIMPLE        @tab Low GIMPLE
@item @code{GIMPLE_ASM}                 @tab x                  @tab x
@item @code{GIMPLE_ASM}                 @tab x                  @tab x
@item @code{GIMPLE_ASSIGN}              @tab x                  @tab x
@item @code{GIMPLE_ASSIGN}              @tab x                  @tab x
@item @code{GIMPLE_BIND}                @tab x                  @tab
@item @code{GIMPLE_BIND}                @tab x                  @tab
@item @code{GIMPLE_CALL}                @tab x                  @tab x
@item @code{GIMPLE_CALL}                @tab x                  @tab x
@item @code{GIMPLE_CATCH}               @tab x                  @tab
@item @code{GIMPLE_CATCH}               @tab x                  @tab
@item @code{GIMPLE_COND}                @tab x                  @tab x
@item @code{GIMPLE_COND}                @tab x                  @tab x
@item @code{GIMPLE_DEBUG}               @tab x                  @tab x
@item @code{GIMPLE_DEBUG}               @tab x                  @tab x
@item @code{GIMPLE_EH_FILTER}           @tab x                  @tab
@item @code{GIMPLE_EH_FILTER}           @tab x                  @tab
@item @code{GIMPLE_GOTO}                @tab x                  @tab x
@item @code{GIMPLE_GOTO}                @tab x                  @tab x
@item @code{GIMPLE_LABEL}               @tab x                  @tab x
@item @code{GIMPLE_LABEL}               @tab x                  @tab x
@item @code{GIMPLE_NOP}                 @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_LOAD}     @tab x                  @tab x
@item @code{GIMPLE_OMP_ATOMIC_STORE}    @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_CONTINUE}        @tab x                  @tab x
@item @code{GIMPLE_OMP_CRITICAL}        @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_FOR}             @tab x                  @tab x
@item @code{GIMPLE_OMP_MASTER}          @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_ORDERED}         @tab x                  @tab x
@item @code{GIMPLE_OMP_PARALLEL}        @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_RETURN}          @tab x                  @tab x
@item @code{GIMPLE_OMP_SECTION}         @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}        @tab x                  @tab x
@item @code{GIMPLE_OMP_SECTIONS_SWITCH} @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_OMP_SINGLE}          @tab x                  @tab x
@item @code{GIMPLE_PHI}                 @tab                    @tab x
@item @code{GIMPLE_PHI}                 @tab                    @tab x
@item @code{GIMPLE_RESX}                @tab                    @tab x
@item @code{GIMPLE_RESX}                @tab                    @tab x
@item @code{GIMPLE_RETURN}              @tab x                  @tab x
@item @code{GIMPLE_RETURN}              @tab x                  @tab x
@item @code{GIMPLE_SWITCH}              @tab x                  @tab x
@item @code{GIMPLE_SWITCH}              @tab x                  @tab x
@item @code{GIMPLE_TRY}                 @tab x                  @tab
@item @code{GIMPLE_TRY}                 @tab x                  @tab
@end multitable
@end multitable
 
 
@node GIMPLE Exception Handling
@node GIMPLE Exception Handling
@section Exception Handling
@section Exception Handling
@cindex GIMPLE Exception Handling
@cindex GIMPLE Exception Handling
 
 
Other exception handling constructs are represented using
Other exception handling constructs are represented using
@code{GIMPLE_TRY_CATCH}.  @code{GIMPLE_TRY_CATCH} has two operands.  The
@code{GIMPLE_TRY_CATCH}.  @code{GIMPLE_TRY_CATCH} has two operands.  The
first operand is a sequence of statements to execute.  If executing
first operand is a sequence of statements to execute.  If executing
these statements does not throw an exception, then the second operand
these statements does not throw an exception, then the second operand
is ignored.  Otherwise, if an exception is thrown, then the second
is ignored.  Otherwise, if an exception is thrown, then the second
operand of the @code{GIMPLE_TRY_CATCH} is checked.  The second
operand of the @code{GIMPLE_TRY_CATCH} is checked.  The second
operand may have the following forms:
operand may have the following forms:
 
 
@enumerate
@enumerate
 
 
@item A sequence of statements to execute.  When an exception occurs,
@item A sequence of statements to execute.  When an exception occurs,
these statements are executed, and then the exception is rethrown.
these statements are executed, and then the exception is rethrown.
 
 
@item A sequence of @code{GIMPLE_CATCH} statements.  Each
@item A sequence of @code{GIMPLE_CATCH} statements.  Each
@code{GIMPLE_CATCH} has a list of applicable exception types and
@code{GIMPLE_CATCH} has a list of applicable exception types and
handler code.  If the thrown exception matches one of the caught
handler code.  If the thrown exception matches one of the caught
types, the associated handler code is executed.  If the handler
types, the associated handler code is executed.  If the handler
code falls off the bottom, execution continues after the original
code falls off the bottom, execution continues after the original
@code{GIMPLE_TRY_CATCH}.
@code{GIMPLE_TRY_CATCH}.
 
 
@item A @code{GIMPLE_EH_FILTER} statement.  This has a list of
@item A @code{GIMPLE_EH_FILTER} statement.  This has a list of
permitted exception types, and code to handle a match failure.  If the
permitted exception types, and code to handle a match failure.  If the
thrown exception does not match one of the allowed types, the
thrown exception does not match one of the allowed types, the
associated match failure code is executed.  If the thrown exception
associated match failure code is executed.  If the thrown exception
does match, it continues unwinding the stack looking for the next
does match, it continues unwinding the stack looking for the next
handler.
handler.
 
 
@end enumerate
@end enumerate
 
 
Currently throwing an exception is not directly represented in
Currently throwing an exception is not directly represented in
GIMPLE, since it is implemented by calling a function.  At some
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
point in the future we will want to add some way to express that
the call will throw an exception of a known type.
the call will throw an exception of a known type.
 
 
Just before running the optimizers, the compiler lowers the
Just before running the optimizers, the compiler lowers the
high-level EH constructs above into a set of @samp{goto}s, magic
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
labels, and EH regions.  Continuing to unwind at the end of a
cleanup is represented with a @code{GIMPLE_RESX}.
cleanup is represented with a @code{GIMPLE_RESX}.
 
 
 
 
@node Temporaries
@node Temporaries
@section Temporaries
@section Temporaries
@cindex Temporaries
@cindex Temporaries
 
 
When gimplification encounters a subexpression that is too
When gimplification encounters a subexpression that is too
complex, it creates a new temporary variable to hold the value of
complex, it creates a new temporary variable to hold the value of
the subexpression, and adds a new statement to initialize it
the subexpression, and adds a new statement to initialize it
before the current statement. These special temporaries are known
before the current statement. These special temporaries are known
as @samp{expression temporaries}, and are allocated using
as @samp{expression temporaries}, and are allocated using
@code{get_formal_tmp_var}.  The compiler tries to always evaluate
@code{get_formal_tmp_var}.  The compiler tries to always evaluate
identical expressions into the same temporary, to simplify
identical expressions into the same temporary, to simplify
elimination of redundant calculations.
elimination of redundant calculations.
 
 
We can only use expression temporaries when we know that it will
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
not be reevaluated before its value is used, and that it will not
be otherwise modified@footnote{These restrictions are derived
be otherwise modified@footnote{These restrictions are derived
from those in Morgan 4.8.}. Other temporaries can be allocated
from those in Morgan 4.8.}. Other temporaries can be allocated
using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
 
 
Currently, an expression like @code{a = b + 5} is not reduced any
Currently, an expression like @code{a = b + 5} is not reduced any
further.  We tried converting it to something like
further.  We tried converting it to something like
@smallexample
@smallexample
  T1 = b + 5;
  T1 = b + 5;
  a = T1;
  a = T1;
@end smallexample
@end smallexample
but this bloated the representation for minimal benefit.  However, a
but this bloated the representation for minimal benefit.  However, a
variable which must live in memory cannot appear in an expression; its
variable which must live in memory cannot appear in an expression; its
value is explicitly loaded into a temporary first.  Similarly, storing
value is explicitly loaded into a temporary first.  Similarly, storing
the value of an expression to a memory variable goes through a
the value of an expression to a memory variable goes through a
temporary.
temporary.
 
 
@node Operands
@node Operands
@section Operands
@section Operands
@cindex Operands
@cindex Operands
 
 
In general, expressions in GIMPLE consist of an operation and the
In general, expressions in GIMPLE consist of an operation and the
appropriate number of simple operands; these operands must either be a
appropriate number of simple operands; these operands must either be a
GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
variable.  More complex operands are factored out into temporaries, so
variable.  More complex operands are factored out into temporaries, so
that
that
@smallexample
@smallexample
  a = b + c + d
  a = b + c + d
@end smallexample
@end smallexample
becomes
becomes
@smallexample
@smallexample
  T1 = b + c;
  T1 = b + c;
  a = T1 + d;
  a = T1 + d;
@end smallexample
@end smallexample
 
 
The same rule holds for arguments to a @code{GIMPLE_CALL}.
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
The target of an assignment is usually a variable, but can also be an
@code{INDIRECT_REF} or a compound lvalue as described below.
@code{INDIRECT_REF} or a compound lvalue as described below.
 
 
@menu
@menu
* Compound Expressions::
* Compound Expressions::
* Compound Lvalues::
* Compound Lvalues::
* Conditional Expressions::
* Conditional Expressions::
* Logical Operators::
* Logical Operators::
@end menu
@end menu
 
 
@node Compound Expressions
@node Compound Expressions
@subsection Compound Expressions
@subsection Compound Expressions
@cindex Compound Expressions
@cindex Compound Expressions
 
 
The left-hand side of a C comma expression is simply moved into a separate
The left-hand side of a C comma expression is simply moved into a separate
statement.
statement.
 
 
@node Compound Lvalues
@node Compound Lvalues
@subsection Compound Lvalues
@subsection Compound Lvalues
@cindex Compound Lvalues
@cindex Compound Lvalues
 
 
Currently compound lvalues involving array and structure field references
Currently compound lvalues involving array and structure field references
are not broken down; an expression like @code{a.b[2] = 42} is not reduced
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
any further (though complex array subscripts are).  This restriction is a
workaround for limitations in later optimizers; if we were to convert this
workaround for limitations in later optimizers; if we were to convert this
to
to
 
 
@smallexample
@smallexample
  T1 = &a.b;
  T1 = &a.b;
  T1[2] = 42;
  T1[2] = 42;
@end smallexample
@end smallexample
 
 
alias analysis would not remember that the reference to @code{T1[2]} came
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
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
another member of @code{a}; this broke @code{struct-alias-1.c}.  Future
optimizer improvements may make this limitation unnecessary.
optimizer improvements may make this limitation unnecessary.
 
 
@node Conditional Expressions
@node Conditional Expressions
@subsection Conditional Expressions
@subsection Conditional Expressions
@cindex Conditional Expressions
@cindex Conditional Expressions
 
 
A C @code{?:} expression is converted into an @code{if} statement with
A C @code{?:} expression is converted into an @code{if} statement with
each branch assigning to the same temporary.  So,
each branch assigning to the same temporary.  So,
 
 
@smallexample
@smallexample
  a = b ? c : d;
  a = b ? c : d;
@end smallexample
@end smallexample
becomes
becomes
@smallexample
@smallexample
  if (b == 1)
  if (b == 1)
    T1 = c;
    T1 = c;
  else
  else
    T1 = d;
    T1 = d;
  a = T1;
  a = T1;
@end smallexample
@end smallexample
 
 
The GIMPLE level if-conversion pass re-introduces @code{?:}
The GIMPLE level if-conversion pass re-introduces @code{?:}
expression, if appropriate. It is used to vectorize loops with
expression, if appropriate. It is used to vectorize loops with
conditions using vector conditional operations.
conditions using vector conditional operations.
 
 
Note that in GIMPLE, @code{if} statements are represented using
Note that in GIMPLE, @code{if} statements are represented using
@code{GIMPLE_COND}, as described below.
@code{GIMPLE_COND}, as described below.
 
 
@node Logical Operators
@node Logical Operators
@subsection Logical Operators
@subsection Logical Operators
@cindex Logical Operators
@cindex Logical Operators
 
 
Except when they appear in the condition operand of a
Except when they appear in the condition operand of a
@code{GIMPLE_COND}, logical `and' and `or' operators are simplified
@code{GIMPLE_COND}, logical `and' and `or' operators are simplified
as follows: @code{a = b && c} becomes
as follows: @code{a = b && c} becomes
 
 
@smallexample
@smallexample
  T1 = (bool)b;
  T1 = (bool)b;
  if (T1 == true)
  if (T1 == true)
    T1 = (bool)c;
    T1 = (bool)c;
  a = T1;
  a = T1;
@end smallexample
@end smallexample
 
 
Note that @code{T1} in this example cannot be an expression temporary,
Note that @code{T1} in this example cannot be an expression temporary,
because it has two different assignments.
because it has two different assignments.
 
 
@subsection Manipulating operands
@subsection Manipulating operands
 
 
All gimple operands are of type @code{tree}.  But only certain
All gimple operands are of type @code{tree}.  But only certain
types of trees are allowed to be used as operand tuples.  Basic
types of trees are allowed to be used as operand tuples.  Basic
validation is controlled by the function
validation is controlled by the function
@code{get_gimple_rhs_class}, which given a tree code, returns an
@code{get_gimple_rhs_class}, which given a tree code, returns an
@code{enum} with the following values of type @code{enum
@code{enum} with the following values of type @code{enum
gimple_rhs_class}
gimple_rhs_class}
 
 
@itemize @bullet
@itemize @bullet
@item @code{GIMPLE_INVALID_RHS}
@item @code{GIMPLE_INVALID_RHS}
The tree cannot be used as a GIMPLE operand.
The tree cannot be used as a GIMPLE operand.
 
 
@item @code{GIMPLE_BINARY_RHS}
@item @code{GIMPLE_BINARY_RHS}
The tree is a valid GIMPLE binary operation.
The tree is a valid GIMPLE binary operation.
 
 
@item @code{GIMPLE_UNARY_RHS}
@item @code{GIMPLE_UNARY_RHS}
The tree is a valid GIMPLE unary operation.
The tree is a valid GIMPLE unary operation.
 
 
@item @code{GIMPLE_SINGLE_RHS}
@item @code{GIMPLE_SINGLE_RHS}
The tree is a single object, that cannot be split into simpler
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).
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
This operand class also acts as an escape hatch for tree nodes
that may be flattened out into the operand vector, but would need
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}
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
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
out on the operand vector using 4 slots, but it would also
require additional processing to distinguish @code{c = a op b}
require additional processing to distinguish @code{c = a op b}
from @code{c = a op b ? x : y}.  Something similar occurs with
from @code{c = a op b ? x : y}.  Something similar occurs with
@code{ASSERT_EXPR}.   In time, these special case tree
@code{ASSERT_EXPR}.   In time, these special case tree
expressions should be flattened into the operand vector.
expressions should be flattened into the operand vector.
@end itemize
@end itemize
 
 
For tree nodes in the categories @code{GIMPLE_BINARY_RHS} and
For tree nodes in the categories @code{GIMPLE_BINARY_RHS} and
@code{GIMPLE_UNARY_RHS}, they cannot be stored inside tuples directly.
@code{GIMPLE_UNARY_RHS}, they cannot be stored inside tuples directly.
They first need to be flattened and separated into individual
They first need to be flattened and separated into individual
components.  For instance, given the GENERIC expression
components.  For instance, given the GENERIC expression
 
 
@smallexample
@smallexample
a = b + c
a = b + c
@end smallexample
@end smallexample
 
 
its tree representation is:
its tree representation is:
 
 
@smallexample
@smallexample
MODIFY_EXPR <VAR_DECL  <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>
MODIFY_EXPR <VAR_DECL  <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>
@end smallexample
@end smallexample
 
 
In this case, the GIMPLE form for this statement is logically
In this case, the GIMPLE form for this statement is logically
identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
on the RHS of the assignment is not represented as a tree,
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
instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree
and flattened into the GIMPLE tuple as follows:
and flattened into the GIMPLE tuple as follows:
 
 
@smallexample
@smallexample
GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>
GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>
@end smallexample
@end smallexample
 
 
@subsection Operand vector allocation
@subsection Operand vector allocation
 
 
The operand vector is stored at the bottom of the three tuple
The operand vector is stored at the bottom of the three tuple
structures that accept operands. This means, that depending on
structures that accept operands. This means, that depending on
the code of a given statement, its operand vector will be at
the code of a given statement, its operand vector will be at
different offsets from the base of the structure.  To access
different offsets from the base of the structure.  To access
tuple operands use the following accessors
tuple operands use the following accessors
 
 
@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
Returns the number of operands in statement G.
Returns the number of operands in statement G.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
Returns operand @code{I} from statement @code{G}.
Returns operand @code{I} from statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
@deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
Returns a pointer into the operand vector for statement @code{G}.  This
Returns a pointer into the operand vector for statement @code{G}.  This
is computed using an internal table called @code{gimple_ops_offset_}[].
is computed using an internal table called @code{gimple_ops_offset_}[].
This table is indexed by the gimple code of @code{G}.
This table is indexed by the gimple code of @code{G}.
 
 
When the compiler is built, this table is filled-in using the
When the compiler is built, this table is filled-in using the
sizes of the structures used by each statement code defined in
sizes of the structures used by each statement code defined in
gimple.def.  Since the operand vector is at the bottom of the
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
structure, for a gimple code @code{C} the offset is computed as sizeof
(struct-of @code{C}) - sizeof (tree).
(struct-of @code{C}) - sizeof (tree).
 
 
This mechanism adds one memory indirection to every access when
This mechanism adds one memory indirection to every access when
using @code{gimple_op}(), if this becomes a bottleneck, a pass can
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
choose to memoize the result from @code{gimple_ops}() and use that to
access the operands.
access the operands.
@end deftypefn
@end deftypefn
 
 
@subsection Operand validation
@subsection Operand validation
 
 
When adding a new operand to a gimple statement, the operand will
When adding a new operand to a gimple statement, the operand will
be validated according to what each tuple accepts in its operand
be validated according to what each tuple accepts in its operand
vector.  These predicates are called by the
vector.  These predicates are called by the
@code{gimple_<name>_set_...()}.  Each tuple will use one of the
@code{gimple_<name>_set_...()}.  Each tuple will use one of the
following predicates (Note, this list is not exhaustive):
following predicates (Note, this list is not exhaustive):
 
 
@deftypefn {GIMPLE function} is_gimple_operand (tree t)
@deftypefn {GIMPLE function} is_gimple_operand (tree t)
This is the most permissive of the predicates.  It essentially
This is the most permissive of the predicates.  It essentially
checks whether t has a @code{gimple_rhs_class} of @code{GIMPLE_SINGLE_RHS}.
checks whether t has a @code{gimple_rhs_class} of @code{GIMPLE_SINGLE_RHS}.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} is_gimple_val (tree t)
@deftypefn {GIMPLE function} is_gimple_val (tree t)
Returns true if t is a "GIMPLE value", which are all the
Returns true if t is a "GIMPLE value", which are all the
non-addressable stack variables (variables for which
non-addressable stack variables (variables for which
@code{is_gimple_reg} returns true) and constants (expressions for which
@code{is_gimple_reg} returns true) and constants (expressions for which
@code{is_gimple_min_invariant} returns true).
@code{is_gimple_min_invariant} returns true).
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_addressable (tree t)
@deftypefn {GIMPLE function} is_gimple_addressable (tree t)
Returns true if t is a symbol or memory reference whose address
Returns true if t is a symbol or memory reference whose address
can be taken.
can be taken.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_asm_val (tree t)
@deftypefn {GIMPLE function} is_gimple_asm_val (tree t)
Similar to @code{is_gimple_val} but it also accepts hard registers.
Similar to @code{is_gimple_val} but it also accepts hard registers.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_call_addr (tree t)
@deftypefn {GIMPLE function} is_gimple_call_addr (tree t)
Return true if t is a valid expression to use as the function
Return true if t is a valid expression to use as the function
called by a @code{GIMPLE_CALL}.
called by a @code{GIMPLE_CALL}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_constant (tree t)
@deftypefn {GIMPLE function} is_gimple_constant (tree t)
Return true if t is a valid gimple constant.
Return true if t is a valid gimple constant.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_min_invariant (tree t)
@deftypefn {GIMPLE function} is_gimple_min_invariant (tree t)
Return true if t is a valid minimal invariant.  This is different
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
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.,
at compile time, but it is known that it doesn't change (e.g.,
the address of a function local variable).
the address of a function local variable).
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_min_invariant_address (tree t)
@deftypefn {GIMPLE function} is_gimple_min_invariant_address (tree t)
Return true if t is an @code{ADDR_EXPR} that does not change once a
Return true if t is an @code{ADDR_EXPR} that does not change once a
function is running.
function is running.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_ip_invariant (tree t)
@deftypefn {GIMPLE function} is_gimple_ip_invariant (tree t)
Return true if t is an interprocedural invariant.  This means that t
Return true if t is an interprocedural invariant.  This means that t
is a valid invariant in all functions (e.g. it can be an address of a
is a valid invariant in all functions (e.g. it can be an address of a
global variable but not of a local one).
global variable but not of a local one).
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_ip_invariant_address (tree t)
@deftypefn {GIMPLE function} is_gimple_ip_invariant_address (tree t)
Return true if t is an @code{ADDR_EXPR} that does not change once the
Return true if t is an @code{ADDR_EXPR} that does not change once the
program is running (and which is valid in all functions).
program is running (and which is valid in all functions).
@end deftypefn
@end deftypefn
 
 
 
 
@subsection Statement validation
@subsection Statement validation
 
 
@deftypefn {GIMPLE function} is_gimple_assign (gimple g)
@deftypefn {GIMPLE function} is_gimple_assign (gimple g)
Return true if the code of g is @code{GIMPLE_ASSIGN}.
Return true if the code of g is @code{GIMPLE_ASSIGN}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_call (gimple g)
@deftypefn {GIMPLE function} is_gimple_call (gimple g)
Return true if the code of g is @code{GIMPLE_CALL}.
Return true if the code of g is @code{GIMPLE_CALL}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} is_gimple_debug (gimple g)
@deftypefn {GIMPLE function} is_gimple_debug (gimple g)
Return true if the code of g is @code{GIMPLE_DEBUG}.
Return true if the code of g is @code{GIMPLE_DEBUG}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_assign_cast_p (gimple g)
@deftypefn {GIMPLE function} gimple_assign_cast_p (gimple g)
Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
operation.
operation.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_debug_bind_p (gimple g)
@deftypefn {GIMPLE function} gimple_debug_bind_p (gimple g)
Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
expression to a variable.
expression to a variable.
@end deftypefn
@end deftypefn
 
 
@node Manipulating GIMPLE statements
@node Manipulating GIMPLE statements
@section Manipulating GIMPLE statements
@section Manipulating GIMPLE statements
@cindex Manipulating GIMPLE statements
@cindex Manipulating GIMPLE statements
 
 
This section documents all the functions available to handle each
This section documents all the functions available to handle each
of the GIMPLE instructions.
of the GIMPLE instructions.
 
 
@subsection Common accessors
@subsection Common accessors
The following are common accessors for gimple statements.
The following are common accessors for gimple statements.
 
 
@deftypefn {GIMPLE function} enum gimple_code gimple_code (gimple g)
@deftypefn {GIMPLE function} enum gimple_code gimple_code (gimple g)
Return the code for statement @code{G}.
Return the code for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
Return the basic block to which statement @code{G} belongs to.
Return the basic block to which statement @code{G} belongs to.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_block (gimple g)
@deftypefn {GIMPLE function} tree gimple_block (gimple g)
Return the lexical scope block holding statement @code{G}.
Return the lexical scope block holding statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
Return the type of the main expression computed by @code{STMT}. Return
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
@code{void_type_node} if @code{STMT} computes nothing. This will only return
something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
@code{GIMPLE_CALL}.  For all other tuple codes, it will return
@code{GIMPLE_CALL}.  For all other tuple codes, it will return
@code{void_type_node}.
@code{void_type_node}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} enum tree_code gimple_expr_code (gimple stmt)
@deftypefn {GIMPLE function} enum tree_code gimple_expr_code (gimple stmt)
Return the tree code for the expression computed by @code{STMT}.  This
Return the tree code for the expression computed by @code{STMT}.  This
is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
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}.
@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_COND}, it returns the code of the comparison predicate.
For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
by the @code{RHS} of the assignment.
by the @code{RHS} of the assignment.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
Set the lexical scope block of @code{G} to @code{BLOCK}.
Set the lexical scope block of @code{G} to @code{BLOCK}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
Return locus information for statement @code{G}.
Return locus information for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
Set locus information for statement @code{G}.
Set locus information for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
Return true if @code{G} does not have locus information.
Return true if @code{G} does not have locus information.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
Return true if no warnings should be emitted for statement @code{STMT}.
Return true if no warnings should be emitted for statement @code{STMT}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
Set the visited status on statement @code{STMT} to @code{VISITED_P}.
Set the visited status on statement @code{STMT} to @code{VISITED_P}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
Return the visited status on statement @code{STMT}.
Return the visited status on statement @code{STMT}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
@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}.
Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} unsigned int gimple_plf (gimple stmt, enum plf_mask plf)
@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}.
Return the value of pass local flag @code{PLF} on statement @code{STMT}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
Return true if statement @code{G} has register or memory operands.
Return true if statement @code{G} has register or memory operands.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
Return true if statement @code{G} has memory operands.
Return true if statement @code{G} has memory operands.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
Return the number of operands for statement @code{G}.
Return the number of operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
@deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
Return the array of operands for statement @code{G}.
Return the array of operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
Return operand @code{I} for statement @code{G}.
Return operand @code{I} for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_op_ptr (gimple g, unsigned i)
@deftypefn {GIMPLE function} tree *gimple_op_ptr (gimple g, unsigned i)
Return a pointer to operand @code{I} for statement @code{G}.
Return a pointer to operand @code{I} for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
Set operand @code{I} of statement @code{G} to @code{OP}.
Set operand @code{I} of statement @code{G} to @code{OP}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
Return the set of symbols that have had their address taken by
Return the set of symbols that have had their address taken by
@code{STMT}.
@code{STMT}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} struct def_optype_d *gimple_def_ops (gimple g)
@deftypefn {GIMPLE function} struct def_optype_d *gimple_def_ops (gimple g)
Return the set of @code{DEF} operands for statement @code{G}.
Return the set of @code{DEF} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
@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}.
Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} struct use_optype_d *gimple_use_ops (gimple g)
@deftypefn {GIMPLE function} struct use_optype_d *gimple_use_ops (gimple g)
Return the set of @code{USE} operands for statement @code{G}.
Return the set of @code{USE} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
@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}.
Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} struct voptype_d *gimple_vuse_ops (gimple g)
@deftypefn {GIMPLE function} struct voptype_d *gimple_vuse_ops (gimple g)
Return the set of @code{VUSE} operands for statement @code{G}.
Return the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
@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}.
Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} struct voptype_d *gimple_vdef_ops (gimple g)
@deftypefn {GIMPLE function} struct voptype_d *gimple_vdef_ops (gimple g)
Return the set of @code{VDEF} operands for statement @code{G}.
Return the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
@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}.
Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
Return the set of symbols loaded by statement @code{G}.  Each element of
Return the set of symbols loaded by statement @code{G}.  Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
Return the set of symbols stored by statement @code{G}.  Each element of
Return the set of symbols stored by statement @code{G}.  Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
Return true if statement @code{G} has operands and the modified field
Return true if statement @code{G} has operands and the modified field
has been set.
has been set.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
Return true if statement @code{STMT} contains volatile operands.
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
Return true if statement @code{STMT} contains volatile operands.
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void update_stmt (gimple s)
@deftypefn {GIMPLE function} void update_stmt (gimple s)
Mark statement @code{S} as modified, and update it.
Mark statement @code{S} as modified, and update it.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
Update statement @code{S} if it has been marked modified.
Update statement @code{S} if it has been marked modified.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
Return a deep copy of statement @code{STMT}.
Return a deep copy of statement @code{STMT}.
@end deftypefn
@end deftypefn
 
 
@node Tuple specific accessors
@node Tuple specific accessors
@section Tuple specific accessors
@section Tuple specific accessors
@cindex Tuple specific accessors
@cindex Tuple specific accessors
 
 
@menu
@menu
* @code{GIMPLE_ASM}::
* @code{GIMPLE_ASM}::
* @code{GIMPLE_ASSIGN}::
* @code{GIMPLE_ASSIGN}::
* @code{GIMPLE_BIND}::
* @code{GIMPLE_BIND}::
* @code{GIMPLE_CALL}::
* @code{GIMPLE_CALL}::
* @code{GIMPLE_CATCH}::
* @code{GIMPLE_CATCH}::
* @code{GIMPLE_COND}::
* @code{GIMPLE_COND}::
* @code{GIMPLE_DEBUG}::
* @code{GIMPLE_DEBUG}::
* @code{GIMPLE_EH_FILTER}::
* @code{GIMPLE_EH_FILTER}::
* @code{GIMPLE_LABEL}::
* @code{GIMPLE_LABEL}::
* @code{GIMPLE_NOP}::
* @code{GIMPLE_NOP}::
* @code{GIMPLE_OMP_ATOMIC_LOAD}::
* @code{GIMPLE_OMP_ATOMIC_LOAD}::
* @code{GIMPLE_OMP_ATOMIC_STORE}::
* @code{GIMPLE_OMP_ATOMIC_STORE}::
* @code{GIMPLE_OMP_CONTINUE}::
* @code{GIMPLE_OMP_CONTINUE}::
* @code{GIMPLE_OMP_CRITICAL}::
* @code{GIMPLE_OMP_CRITICAL}::
* @code{GIMPLE_OMP_FOR}::
* @code{GIMPLE_OMP_FOR}::
* @code{GIMPLE_OMP_MASTER}::
* @code{GIMPLE_OMP_MASTER}::
* @code{GIMPLE_OMP_ORDERED}::
* @code{GIMPLE_OMP_ORDERED}::
* @code{GIMPLE_OMP_PARALLEL}::
* @code{GIMPLE_OMP_PARALLEL}::
* @code{GIMPLE_OMP_RETURN}::
* @code{GIMPLE_OMP_RETURN}::
* @code{GIMPLE_OMP_SECTION}::
* @code{GIMPLE_OMP_SECTION}::
* @code{GIMPLE_OMP_SECTIONS}::
* @code{GIMPLE_OMP_SECTIONS}::
* @code{GIMPLE_OMP_SINGLE}::
* @code{GIMPLE_OMP_SINGLE}::
* @code{GIMPLE_PHI}::
* @code{GIMPLE_PHI}::
* @code{GIMPLE_RESX}::
* @code{GIMPLE_RESX}::
* @code{GIMPLE_RETURN}::
* @code{GIMPLE_RETURN}::
* @code{GIMPLE_SWITCH}::
* @code{GIMPLE_SWITCH}::
* @code{GIMPLE_TRY}::
* @code{GIMPLE_TRY}::
* @code{GIMPLE_WITH_CLEANUP_EXPR}::
* @code{GIMPLE_WITH_CLEANUP_EXPR}::
@end menu
@end menu
 
 
 
 
@node @code{GIMPLE_ASM}
@node @code{GIMPLE_ASM}
@subsection @code{GIMPLE_ASM}
@subsection @code{GIMPLE_ASM}
@cindex @code{GIMPLE_ASM}
@cindex @code{GIMPLE_ASM}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
Build a @code{GIMPLE_ASM} statement.  This statement is used for
Build a @code{GIMPLE_ASM} statement.  This statement is used for
building in-line assembly constructs.  @code{STRING} is the assembly
building in-line assembly constructs.  @code{STRING} is the assembly
code.  @code{NINPUT} is the number of register inputs.  @code{NOUTPUT} is the
code.  @code{NINPUT} is the number of register inputs.  @code{NOUTPUT} is the
number of register outputs.  @code{NCLOBBERS} is the number of clobbered
number of register outputs.  @code{NCLOBBERS} is the number of clobbered
registers.  The rest of the arguments trees for each input,
registers.  The rest of the arguments trees for each input,
output, and clobbered registers.
output, and clobbered registers.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
@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
Identical to gimple_build_asm, but the arguments are passed in
VECs.
VECs.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_asm_ninputs (gimple g)
@deftypefn {GIMPLE function} gimple_asm_ninputs (gimple g)
Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_asm_noutputs (gimple g)
@deftypefn {GIMPLE function} gimple_asm_noutputs (gimple g)
Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_asm_nclobbers (gimple g)
@deftypefn {GIMPLE function} gimple_asm_nclobbers (gimple g)
Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
@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}.
Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
unsigned index, tree out_op)
unsigned index, tree out_op)
Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
@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}.
Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} const char *gimple_asm_string (gimple g)
@deftypefn {GIMPLE function} const char *gimple_asm_string (gimple g)
Return the string representing the assembly instruction in
Return the string representing the assembly instruction in
@code{GIMPLE_ASM} @code{G}.
@code{GIMPLE_ASM} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
Return true if @code{G} is an asm statement marked volatile.
Return true if @code{G} is an asm statement marked volatile.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
Mark asm statement @code{G} as volatile.
Mark asm statement @code{G} as volatile.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
@deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
Remove volatile marker from asm statement @code{G}.
Remove volatile marker from asm statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_ASSIGN}
@node @code{GIMPLE_ASSIGN}
@subsection @code{GIMPLE_ASSIGN}
@subsection @code{GIMPLE_ASSIGN}
@cindex @code{GIMPLE_ASSIGN}
@cindex @code{GIMPLE_ASSIGN}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
Build a @code{GIMPLE_ASSIGN} statement.  The left-hand side is an lvalue
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
passed in lhs.  The right-hand side can be either a unary or
binary tree expression.  The expression tree rhs will be
binary tree expression.  The expression tree rhs will be
flattened and its operands assigned to the corresponding operand
flattened and its operands assigned to the corresponding operand
slots in the new statement.  This function is useful when you
slots in the new statement.  This function is useful when you
already have a tree expression that you want to convert into a
already have a tree expression that you want to convert into a
tuple.  However, try to avoid building expression trees for the
tuple.  However, try to avoid building expression trees for the
sole purpose of calling this function.  If you already have the
sole purpose of calling this function.  If you already have the
operands in separate trees, it is better to use
operands in separate trees, it is better to use
@code{gimple_build_assign_with_ops}.
@code{gimple_build_assign_with_ops}.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
@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
Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
@code{*SEQ_P}.
@code{*SEQ_P}.
@end deftypefn
@end deftypefn
 
 
@code{DST}/@code{SRC} are the destination and source respectively.  You can
@code{DST}/@code{SRC} are the destination and source respectively.  You can
pass ungimplified trees in @code{DST} or @code{SRC}, in which
pass ungimplified trees in @code{DST} or @code{SRC}, in which
case they will be converted to a gimple operand if necessary.
case they will be converted to a gimple operand if necessary.
 
 
This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
 
 
@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
(enum tree_code subcode, tree lhs, tree op1, tree op2)
(enum tree_code subcode, tree lhs, tree op1, tree op2)
This function is similar to @code{gimple_build_assign}, but is used to
This function is similar to @code{gimple_build_assign}, but is used to
build a @code{GIMPLE_ASSIGN} statement when the operands of the
build a @code{GIMPLE_ASSIGN} statement when the operands of the
right-hand side of the assignment are already split into
right-hand side of the assignment are already split into
different operands.
different operands.
 
 
The left-hand side is an lvalue passed in lhs.  Subcode is the
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
@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}
are the operands.  If op2 is null, subcode must be a @code{tree_code}
for a unary expression.
for a unary expression.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} enum tree_code gimple_assign_rhs_code (gimple g)
@deftypefn {GIMPLE function} enum tree_code gimple_assign_rhs_code (gimple g)
Return the code of the expression computed on the @code{RHS} of
Return the code of the expression computed on the @code{RHS} of
assignment statement @code{G}.
assignment statement @code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} enum gimple_rhs_class gimple_assign_rhs_class (gimple g)
@deftypefn {GIMPLE function} enum gimple_rhs_class gimple_assign_rhs_class (gimple g)
Return the gimple rhs class of the code for the expression
Return the gimple rhs class of the code for the expression
computed on the rhs of assignment statement @code{G}.  This will never
computed on the rhs of assignment statement @code{G}.  This will never
return @code{GIMPLE_INVALID_RHS}.
return @code{GIMPLE_INVALID_RHS}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
Return the @code{LHS} of assignment statement @code{G}.
Return the @code{LHS} of assignment statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_assign_lhs_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_assign_lhs_ptr (gimple g)
Return a pointer to the @code{LHS} of assignment statement @code{G}.
Return a pointer to the @code{LHS} of assignment statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
Return the first operand on the @code{RHS} of assignment statement @code{G}.
Return the first operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_assign_rhs1_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_assign_rhs1_ptr (gimple g)
Return the address of the first operand on the @code{RHS} of assignment
Return the address of the first operand on the @code{RHS} of assignment
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
Return the second operand on the @code{RHS} of assignment statement @code{G}.
Return the second operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
Return the address of the second operand on the @code{RHS} of assignment
Return the address of the second operand on the @code{RHS} of assignment
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
@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}.
Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
@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
Set @code{RHS} to be the first operand on the @code{RHS} of assignment
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
Return the second operand on the @code{RHS} of assignment statement @code{G}.
Return the second operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
Return a pointer to the second operand on the @code{RHS} of assignment
Return a pointer to the second operand on the @code{RHS} of assignment
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
@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
Set @code{RHS} to be the second operand on the @code{RHS} of assignment
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
Return true if @code{S} is a type-cast assignment.
Return true if @code{S} is a type-cast assignment.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_BIND}
@node @code{GIMPLE_BIND}
@subsection @code{GIMPLE_BIND}
@subsection @code{GIMPLE_BIND}
@cindex @code{GIMPLE_BIND}
@cindex @code{GIMPLE_BIND}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
@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}
Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
and a body of statements in sequence @code{BODY}.
and a body of statements in sequence @code{BODY}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
@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}
Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
@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}
Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
@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}.
Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
@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.
Append a statement to the end of a @code{GIMPLE_BIND}'s body.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
@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
Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
body.
body.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
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.
@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
@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}
Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_CALL}
@node @code{GIMPLE_CALL}
@subsection @code{GIMPLE_CALL}
@subsection @code{GIMPLE_CALL}
@cindex @code{GIMPLE_CALL}
@cindex @code{GIMPLE_CALL}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
@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}
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
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
determined by @code{is_gimple_call_addr}.  @code{NARGS} are the number of
arguments.  The rest of the arguments follow the argument @code{NARGS},
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
and must be trees that are valid as rvalues in gimple (i.e., each
operand is validated with @code{is_gimple_operand}).
operand is validated with @code{is_gimple_operand}).
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
@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
Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node.  The arguments and the
function are taken from the expression directly.  This routine
function are taken from the expression directly.  This routine
assumes that @code{call_expr} is already in GIMPLE form.  That is, its
assumes that @code{call_expr} is already in GIMPLE form.  That is, its
operands are GIMPLE values and the function call needs no further
operands are GIMPLE values and the function call needs no further
simplification.  All the call flags in @code{call_expr} are copied over
simplification.  All the call flags in @code{call_expr} are copied over
to the new @code{GIMPLE_CALL}.
to the new @code{GIMPLE_CALL}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
@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
Identical to @code{gimple_build_call} but the arguments are stored in a
@code{VEC}().
@code{VEC}().
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
Return the @code{LHS} of call statement @code{G}.
Return the @code{LHS} of call statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_call_lhs_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_call_lhs_ptr (gimple g)
Return a pointer to the @code{LHS} of call statement @code{G}.
Return a pointer to the @code{LHS} of call statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
@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}.
Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
Return the tree node representing the function called by call
Return the tree node representing the function called by call
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
@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
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
to be a gimple value specifying the address of the called
function.
function.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
Otherwise return @code{NULL}.  This function is analogous to
Otherwise return @code{NULL}.  This function is analogous to
@code{get_callee_fndecl} in @code{GENERIC}.
@code{get_callee_fndecl} in @code{GENERIC}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
Set the called function to @code{FNDECL}.
Set the called function to @code{FNDECL}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
Return the type returned by call statement @code{G}.
Return the type returned by call statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
Return the static chain for call statement @code{G}.
Return the static chain for call statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
@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}.
Set @code{CHAIN} to be the static chain for call statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_call_num_args (gimple g)
@deftypefn {GIMPLE function} gimple_call_num_args (gimple g)
Return the number of arguments used by call statement @code{G}.
Return the number of arguments used by call statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
Return the argument at position @code{INDEX} for call statement @code{G}.  The
Return the argument at position @code{INDEX} for call statement @code{G}.  The
first argument is 0.
first argument is 0.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_call_arg_ptr (gimple g, unsigned index)
@deftypefn {GIMPLE function} tree *gimple_call_arg_ptr (gimple g, unsigned index)
Return a pointer to the argument at position @code{INDEX} for call
Return a pointer to the argument at position @code{INDEX} for call
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
@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
Set @code{ARG} to be the argument at position @code{INDEX} for call statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
@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
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
before the exit of a function). These calls are candidate for
tail call optimization.
tail call optimization.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
Return true if @code{S} is a noreturn call.
Return true if @code{S} is a noreturn call.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
in the positions marked by the set @code{ARGS_TO_SKIP}.
in the positions marked by the set @code{ARGS_TO_SKIP}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_CATCH}
@node @code{GIMPLE_CATCH}
@subsection @code{GIMPLE_CATCH}
@subsection @code{GIMPLE_CATCH}
@cindex @code{GIMPLE_CATCH}
@cindex @code{GIMPLE_CATCH}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
@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
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
catch handles.  @code{HANDLER} is a sequence of statements with the code
for the handler.
for the handler.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_catch_types_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_catch_types_ptr (gimple g)
Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
Return the GIMPLE sequence representing the body of the handler
Return the GIMPLE sequence representing the body of the handler
of @code{GIMPLE_CATCH} statement @code{G}.
of @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
@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}.
Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
@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}.
Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_COND}
@node @code{GIMPLE_COND}
@subsection @code{GIMPLE_COND}
@subsection @code{GIMPLE_COND}
@cindex @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)
@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
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
@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}.
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{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
@code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
@code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
@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
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}.
tree @code{COND}.  @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} enum tree_code gimple_cond_code (gimple g)
@deftypefn {GIMPLE function} enum tree_code gimple_cond_code (gimple g)
Return the code of the predicate computed by conditional
Return the code of the predicate computed by conditional
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
@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
Set @code{CODE} to be the predicate code for the conditional statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
Return the @code{LHS} of the predicate computed by conditional statement
Return the @code{LHS} of the predicate computed by conditional statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
@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
Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
conditional statement @code{G}.
conditional statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
Return the @code{RHS} operand of the predicate computed by conditional
Return the @code{RHS} operand of the predicate computed by conditional
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
@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
Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
conditional statement @code{G}.
conditional statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
Return the label used by conditional statement @code{G} when its
Return the label used by conditional statement @code{G} when its
predicate evaluates to true.
predicate evaluates to true.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
@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
Set @code{LABEL} to be the label used by conditional statement @code{G} when
its predicate evaluates to true.
its predicate evaluates to true.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
@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
Set @code{LABEL} to be the label used by conditional statement @code{G} when
its predicate evaluates to false.
its predicate evaluates to false.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
Return the label used by conditional statement @code{G} when its
Return the label used by conditional statement @code{G} when its
predicate evaluates to false.
predicate evaluates to false.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_DEBUG}
@node @code{GIMPLE_DEBUG}
@subsection @code{GIMPLE_DEBUG}
@subsection @code{GIMPLE_DEBUG}
@cindex @code{GIMPLE_DEBUG}
@cindex @code{GIMPLE_DEBUG}
@cindex @code{GIMPLE_DEBUG_BIND}
@cindex @code{GIMPLE_DEBUG_BIND}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_debug_bind (tree var, tree value, gimple stmt)
@deftypefn {GIMPLE function} gimple gimple_build_debug_bind (tree var, tree value, gimple stmt)
Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of
Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of
@code{subcode}.  The effect of this statement is to tell debug
@code{subcode}.  The effect of this statement is to tell debug
information generation machinery that the value of user variable
information generation machinery that the value of user variable
@code{var} is given by @code{value} at that point, and to remain with
@code{var} is given by @code{value} at that point, and to remain with
that value until @code{var} runs out of scope, a
that value until @code{var} runs out of scope, a
dynamically-subsequent debug bind statement overrides the binding, or
dynamically-subsequent debug bind statement overrides the binding, or
conflicting values reach a control flow merge point.  Even if
conflicting values reach a control flow merge point.  Even if
components of the @code{value} expression change afterwards, the
components of the @code{value} expression change afterwards, the
variable is supposed to retain the same value, though not necessarily
variable is supposed to retain the same value, though not necessarily
the same location.
the same location.
 
 
It is expected that @code{var} be most often a tree for automatic user
It is expected that @code{var} be most often a tree for automatic user
variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the
variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the
requirements for gimple registers, but it may also be a tree for a
requirements for gimple registers, but it may also be a tree for a
scalarized component of a user variable (@code{ARRAY_REF},
scalarized component of a user variable (@code{ARRAY_REF},
@code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}).
@code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}).
 
 
As for @code{value}, it can be an arbitrary tree expression, but it is
As for @code{value}, it can be an arbitrary tree expression, but it is
recommended that it be in a suitable form for a gimple assignment
recommended that it be in a suitable form for a gimple assignment
@code{RHS}.  It is not expected that user variables that could appear
@code{RHS}.  It is not expected that user variables that could appear
as @code{var} ever appear in @code{value}, because in the latter we'd
as @code{var} ever appear in @code{value}, because in the latter we'd
have their @code{SSA_NAME}s instead, but even if they were not in SSA
have their @code{SSA_NAME}s instead, but even if they were not in SSA
form, user variables appearing in @code{value} are to be regarded as
form, user variables appearing in @code{value} are to be regarded as
part of the executable code space, whereas those in @code{var} are to
part of the executable code space, whereas those in @code{var} are to
be regarded as part of the source code space.  There is no way to
be regarded as part of the source code space.  There is no way to
refer to the value bound to a user variable within a @code{value}
refer to the value bound to a user variable within a @code{value}
expression.
expression.
 
 
If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
generation machinery is informed that the variable @code{var} is
generation machinery is informed that the variable @code{var} is
unbound, i.e., that its value is indeterminate, which sometimes means
unbound, i.e., that its value is indeterminate, which sometimes means
it is really unavailable, and other times that the compiler could not
it is really unavailable, and other times that the compiler could not
keep track of it.
keep track of it.
 
 
Block and location information for the newly-created stmt are
Block and location information for the newly-created stmt are
taken from @code{stmt}, if given.
taken from @code{stmt}, if given.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
Return the user variable @var{var} that is bound at @code{stmt}.
Return the user variable @var{var} that is bound at @code{stmt}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
Return the value expression that is bound to a user variable at
Return the value expression that is bound to a user variable at
@code{stmt}.
@code{stmt}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_debug_bind_get_value_ptr (gimple stmt)
@deftypefn {GIMPLE function} tree *gimple_debug_bind_get_value_ptr (gimple stmt)
Return a pointer to the value expression that is bound to a user
Return a pointer to the value expression that is bound to a user
variable at @code{stmt}.
variable at @code{stmt}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
Modify the user variable bound at @code{stmt} to @var{var}.
Modify the user variable bound at @code{stmt} to @var{var}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
Modify the value bound to the user variable bound at @code{stmt} to
Modify the value bound to the user variable bound at @code{stmt} to
@var{value}.
@var{value}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
Modify the value bound to the user variable bound at @code{stmt} so
Modify the value bound to the user variable bound at @code{stmt} so
that the variable becomes unbound.
that the variable becomes unbound.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
Return @code{TRUE} if @code{stmt} binds a user variable to a value,
Return @code{TRUE} if @code{stmt} binds a user variable to a value,
and @code{FALSE} if it unbinds the variable.
and @code{FALSE} if it unbinds the variable.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_EH_FILTER}
@node @code{GIMPLE_EH_FILTER}
@subsection @code{GIMPLE_EH_FILTER}
@subsection @code{GIMPLE_EH_FILTER}
@cindex @code{GIMPLE_EH_FILTER}
@cindex @code{GIMPLE_EH_FILTER}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
@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
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.
types.  @code{FAILURE} is a sequence with the filter's failure action.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_eh_filter_types_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_eh_filter_types_ptr (gimple g)
Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
statement fails.
statement fails.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
@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}.
Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
@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
Set @code{FAILURE} to be the sequence of statements to execute on
failure for @code{GIMPLE_EH_FILTER} @code{G}.
failure for @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_LABEL}
@node @code{GIMPLE_LABEL}
@subsection @code{GIMPLE_LABEL}
@subsection @code{GIMPLE_LABEL}
@cindex @code{GIMPLE_LABEL}
@cindex @code{GIMPLE_LABEL}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
@deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
label, @code{LABEL}.
label, @code{LABEL}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
@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}
Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
Return the destination of the unconditional jump @code{G}.
Return the destination of the unconditional jump @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
Set @code{DEST} to be the destination of the unconditional jump @code{G}.
Set @code{DEST} to be the destination of the unconditional jump @code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_NOP}
@node @code{GIMPLE_NOP}
@subsection @code{GIMPLE_NOP}
@subsection @code{GIMPLE_NOP}
@cindex @code{GIMPLE_NOP}
@cindex @code{GIMPLE_NOP}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_nop (void)
@deftypefn {GIMPLE function} gimple gimple_build_nop (void)
Build a @code{GIMPLE_NOP} statement.
Build a @code{GIMPLE_NOP} statement.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_OMP_ATOMIC_LOAD}
@node @code{GIMPLE_OMP_ATOMIC_LOAD}
@subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
@subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
@cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
@cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
@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
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
side of the assignment.  @code{RHS} is the right-hand side of the
assignment.
assignment.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
Set the @code{LHS} of an atomic load.
Set the @code{LHS} of an atomic load.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
Get the @code{LHS} of an atomic load.
Get the @code{LHS} of an atomic load.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
Set the @code{RHS} of an atomic set.
Set the @code{RHS} of an atomic set.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
Get the @code{RHS} of an atomic set.
Get the @code{RHS} of an atomic set.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_OMP_ATOMIC_STORE}
@node @code{GIMPLE_OMP_ATOMIC_STORE}
@subsection @code{GIMPLE_OMP_ATOMIC_STORE}
@subsection @code{GIMPLE_OMP_ATOMIC_STORE}
@cindex @code{GIMPLE_OMP_ATOMIC_STORE}
@cindex @code{GIMPLE_OMP_ATOMIC_STORE}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
@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
Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
stored.
stored.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
Set the value being stored in an atomic store.
Set the value being stored in an atomic store.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
Return the value being stored in an atomic store.
Return the value being stored in an atomic store.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_OMP_CONTINUE}
@node @code{GIMPLE_OMP_CONTINUE}
@subsection @code{GIMPLE_OMP_CONTINUE}
@subsection @code{GIMPLE_OMP_CONTINUE}
@cindex @code{GIMPLE_OMP_CONTINUE}
@cindex @code{GIMPLE_OMP_CONTINUE}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
@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
Build a @code{GIMPLE_OMP_CONTINUE} statement.  @code{CONTROL_DEF} is the
definition of the control variable.  @code{CONTROL_USE} is the use of
definition of the control variable.  @code{CONTROL_USE} is the use of
the control variable.
the control variable.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
Return the definition of the control variable on a
Return the definition of the control variable on a
@code{GIMPLE_OMP_CONTINUE} in @code{S}.
@code{GIMPLE_OMP_CONTINUE} in @code{S}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
Same as above, but return the pointer.
Same as above, but return the pointer.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
statement in @code{S}.
statement in @code{S}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
in @code{S}.
in @code{S}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
Same as above, but return the pointer.
Same as above, but return the pointer.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
in @code{S}.
in @code{S}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_OMP_CRITICAL}
@node @code{GIMPLE_OMP_CRITICAL}
@subsection @code{GIMPLE_OMP_CRITICAL}
@subsection @code{GIMPLE_OMP_CRITICAL}
@cindex @code{GIMPLE_OMP_CRITICAL}
@cindex @code{GIMPLE_OMP_CRITICAL}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
@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
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
statements for which only one thread can execute.  @code{NAME} is an
optional identifier for this critical block.
optional identifier for this critical block.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_critical_name_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_critical_name_ptr (gimple g)
Return a pointer to the name associated with @code{OMP} critical
Return a pointer to the name associated with @code{OMP} critical
statement @code{G}.
statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
@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}.
Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_OMP_FOR}
@node @code{GIMPLE_OMP_FOR}
@subsection @code{GIMPLE_OMP_FOR}
@subsection @code{GIMPLE_OMP_FOR}
@cindex @code{GIMPLE_OMP_FOR}
@cindex @code{GIMPLE_OMP_FOR}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
tree clauses, tree index, tree initial, tree final, tree incr, @
tree clauses, tree index, tree initial, tree final, tree incr, @
gimple_seq pre_body, enum tree_code omp_for_cond)
gimple_seq pre_body, enum tree_code omp_for_cond)
Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
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
inside the for loop.  @code{CLAUSES}, are any of the @code{OMP} loop
construct's clauses: private, firstprivate,  lastprivate,
construct's clauses: private, firstprivate,  lastprivate,
reductions, ordered, schedule, and nowait.  @code{PRE_BODY} is the
reductions, ordered, schedule, and nowait.  @code{PRE_BODY} is the
sequence of statements that are loop invariant.  @code{INDEX} 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
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
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.
compare @code{INDEX} and @code{FINAL}.  @code{INCR} is the increment expression.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
Return the clauses associated with @code{OMP_FOR} @code{G}.
Return the clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_for_clauses_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_for_clauses_ptr (gimple g)
Return a pointer to the @code{OMP_FOR} @code{G}.
Return a pointer to the @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
@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}.
Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
Return the index variable for @code{OMP_FOR} @code{G}.
Return the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_for_index_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_for_index_ptr (gimple g)
Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
@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}.
Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
Return the initial value for @code{OMP_FOR} @code{G}.
Return the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_for_initial_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_for_initial_ptr (gimple g)
Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
Return the final value for @code{OMP_FOR} @code{G}.
Return the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_for_final_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_for_final_ptr (gimple g)
turn a pointer to the final value for @code{OMP_FOR} @code{G}.
turn a pointer to the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
@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}.
Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
Return the increment value for @code{OMP_FOR} @code{G}.
Return the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_for_incr_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_for_incr_ptr (gimple g)
Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
@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}.
Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
Return the sequence of statements to execute before the @code{OMP_FOR}
Return the sequence of statements to execute before the @code{OMP_FOR}
statement @code{G} starts.
statement @code{G} starts.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
@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
Set @code{PRE_BODY} to be the sequence of statements to execute before
the @code{OMP_FOR} statement @code{G} starts.
the @code{OMP_FOR} statement @code{G} starts.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
@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}.
Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} enum tree_code gimple_omp_for_cond (gimple g)
@deftypefn {GIMPLE function} enum tree_code gimple_omp_for_cond (gimple g)
Return the condition code associated with @code{OMP_FOR} @code{G}.
Return the condition code associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_OMP_MASTER}
@node @code{GIMPLE_OMP_MASTER}
@subsection @code{GIMPLE_OMP_MASTER}
@subsection @code{GIMPLE_OMP_MASTER}
@cindex @code{GIMPLE_OMP_MASTER}
@cindex @code{GIMPLE_OMP_MASTER}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
@deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
statements to be executed by just the master.
statements to be executed by just the master.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_OMP_ORDERED}
@node @code{GIMPLE_OMP_ORDERED}
@subsection @code{GIMPLE_OMP_ORDERED}
@subsection @code{GIMPLE_OMP_ORDERED}
@cindex @code{GIMPLE_OMP_ORDERED}
@cindex @code{GIMPLE_OMP_ORDERED}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
Build a @code{GIMPLE_OMP_ORDERED} statement.
Build a @code{GIMPLE_OMP_ORDERED} statement.
@end deftypefn
@end deftypefn
 
 
@code{BODY} is the sequence of statements inside a loop that will
@code{BODY} is the sequence of statements inside a loop that will
executed in sequence.
executed in sequence.
 
 
 
 
@node @code{GIMPLE_OMP_PARALLEL}
@node @code{GIMPLE_OMP_PARALLEL}
@subsection @code{GIMPLE_OMP_PARALLEL}
@subsection @code{GIMPLE_OMP_PARALLEL}
@cindex @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)
@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.
Build a @code{GIMPLE_OMP_PARALLEL} statement.
@end deftypefn
@end deftypefn
 
 
@code{BODY} is sequence of statements which are executed in parallel.
@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
@code{CLAUSES}, are the @code{OMP} parallel construct's clauses.  @code{CHILD_FN} is
the function created for the parallel threads to execute.
the function created for the parallel threads to execute.
@code{DATA_ARG} are the shared data argument(s).
@code{DATA_ARG} are the shared data argument(s).
 
 
@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
Return true if @code{OMP} parallel statement @code{G} has the
Return true if @code{OMP} parallel statement @code{G} has the
@code{GF_OMP_PARALLEL_COMBINED} flag set.
@code{GF_OMP_PARALLEL_COMBINED} flag set.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
@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
Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
Return the body for the @code{OMP} statement @code{G}.
Return the body for the @code{OMP} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
@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}.
Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_parallel_clauses_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_parallel_clauses_ptr (gimple g)
Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
Set @code{CLAUSES} to be the list of clauses associated with
Set @code{CLAUSES} to be the list of clauses associated with
@code{OMP_PARALLEL} @code{G}.
@code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
Return the child function used to hold the body of @code{OMP_PARALLEL}
Return the child function used to hold the body of @code{OMP_PARALLEL}
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_parallel_child_fn_ptr (gimple g)
@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
Return a pointer to the child function used to hold the body of
@code{OMP_PARALLEL} @code{G}.
@code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
@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}.
Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
Return the artificial argument used to send variables and values
Return the artificial argument used to send variables and values
from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_parallel_data_arg_ptr (gimple g)
@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}.
Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
@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}.
Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt)
@deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt)
Returns true when the gimple statement @code{STMT} is any of the OpenMP
Returns true when the gimple statement @code{STMT} is any of the OpenMP
types.
types.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_OMP_RETURN}
@node @code{GIMPLE_OMP_RETURN}
@subsection @code{GIMPLE_OMP_RETURN}
@subsection @code{GIMPLE_OMP_RETURN}
@cindex @code{GIMPLE_OMP_RETURN}
@cindex @code{GIMPLE_OMP_RETURN}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
@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
Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
non-waiting return.
non-waiting return.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
Return true if @code{OMP} return statement @code{G} has the
Return true if @code{OMP} return statement @code{G} has the
@code{GF_OMP_RETURN_NOWAIT} flag set.
@code{GF_OMP_RETURN_NOWAIT} flag set.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_OMP_SECTION}
@node @code{GIMPLE_OMP_SECTION}
@subsection @code{GIMPLE_OMP_SECTION}
@subsection @code{GIMPLE_OMP_SECTION}
@cindex @code{GIMPLE_OMP_SECTION}
@cindex @code{GIMPLE_OMP_SECTION}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
@end deftypefn
@end deftypefn
 
 
@code{BODY} is the sequence of statements in the section.
@code{BODY} is the sequence of statements in the section.
 
 
@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
Return true if @code{OMP} section statement @code{G} has the
Return true if @code{OMP} section statement @code{G} has the
@code{GF_OMP_SECTION_LAST} flag set.
@code{GF_OMP_SECTION_LAST} flag set.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_OMP_SECTIONS}
@node @code{GIMPLE_OMP_SECTIONS}
@subsection @code{GIMPLE_OMP_SECTIONS}
@subsection @code{GIMPLE_OMP_SECTIONS}
@cindex @code{GIMPLE_OMP_SECTIONS}
@cindex @code{GIMPLE_OMP_SECTIONS}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
@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
Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
section statements.  @code{CLAUSES} are any of the @code{OMP} sections
section statements.  @code{CLAUSES} are any of the @code{OMP} sections
construct's clauses: private, firstprivate, lastprivate,
construct's clauses: private, firstprivate, lastprivate,
reduction, and nowait.
reduction, and nowait.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
@deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
Return the control variable associated with the
Return the control variable associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_sections_control_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_sections_control_ptr (gimple g)
Return a pointer to the clauses associated with the
Return a pointer to the clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
@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
Set @code{CONTROL} to be the set of clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_sections_clauses_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_sections_clauses_ptr (gimple g)
Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
@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}
Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_OMP_SINGLE}
@node @code{GIMPLE_OMP_SINGLE}
@subsection @code{GIMPLE_OMP_SINGLE}
@subsection @code{GIMPLE_OMP_SINGLE}
@cindex @code{GIMPLE_OMP_SINGLE}
@cindex @code{GIMPLE_OMP_SINGLE}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
@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
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
statements that will be executed once.  @code{CLAUSES} are any of the
@code{OMP} single construct's clauses: private, firstprivate,
@code{OMP} single construct's clauses: private, firstprivate,
copyprivate, nowait.
copyprivate, nowait.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
Return the clauses associated with @code{OMP_SINGLE} @code{G}.
Return the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_omp_single_clauses_ptr (gimple g)
@deftypefn {GIMPLE function} tree *gimple_omp_single_clauses_ptr (gimple g)
Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
@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}.
Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_PHI}
@node @code{GIMPLE_PHI}
@subsection @code{GIMPLE_PHI}
@subsection @code{GIMPLE_PHI}
@cindex @code{GIMPLE_PHI}
@cindex @code{GIMPLE_PHI}
 
 
@deftypefn {GIMPLE function} gimple make_phi_node (tree var, int len)
@deftypefn {GIMPLE function} gimple make_phi_node (tree var, int len)
Build a @code{PHI} node with len argument slots for variable var.
Build a @code{PHI} node with len argument slots for variable var.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
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
be exactly the number of incoming edges for the basic block
holding @code{G}.
holding @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree *gimple_phi_result_ptr (gimple g)
@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}.
Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
@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}.
Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} struct phi_arg_d *gimple_phi_arg (gimple g, index)
@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
Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
@code{GIMPLE_PHI} @code{G}.
@code{GIMPLE_PHI} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
@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
Set @code{PHIARG} to be the argument corresponding to incoming edge
@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_RESX}
@node @code{GIMPLE_RESX}
@subsection @code{GIMPLE_RESX}
@subsection @code{GIMPLE_RESX}
@cindex @code{GIMPLE_RESX}
@cindex @code{GIMPLE_RESX}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
@deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
Build a @code{GIMPLE_RESX} statement which is a statement.  This
Build a @code{GIMPLE_RESX} statement which is a statement.  This
statement is a placeholder for _Unwind_Resume before we know if a
statement is a placeholder for _Unwind_Resume before we know if a
function call or a branch is needed.  @code{REGION} is the exception
function call or a branch is needed.  @code{REGION} is the exception
region from which control is flowing.
region from which control is flowing.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
Return the region number for @code{GIMPLE_RESX} @code{G}.
Return the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
@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}.
Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_RETURN}
@node @code{GIMPLE_RETURN}
@subsection @code{GIMPLE_RETURN}
@subsection @code{GIMPLE_RETURN}
@cindex @code{GIMPLE_RETURN}
@cindex @code{GIMPLE_RETURN}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
Build a @code{GIMPLE_RETURN} statement whose return value is retval.
Build a @code{GIMPLE_RETURN} statement whose return value is retval.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
Return the return value for @code{GIMPLE_RETURN} @code{G}.
Return the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
@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}.
Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_SWITCH}
@node @code{GIMPLE_SWITCH}
@subsection @code{GIMPLE_SWITCH}
@subsection @code{GIMPLE_SWITCH}
@cindex @code{GIMPLE_SWITCH}
@cindex @code{GIMPLE_SWITCH}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_switch ( nlabels, tree index, tree default_label, ...)
@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
Build a @code{GIMPLE_SWITCH} statement.  @code{NLABELS} are the number of
labels excluding the default label.  The default label is passed
labels excluding the default label.  The default label is passed
in @code{DEFAULT_LABEL}.  The rest of the arguments are trees
in @code{DEFAULT_LABEL}.  The rest of the arguments are trees
representing the labels.  Each label is a tree of code
representing the labels.  Each label is a tree of code
@code{CASE_LABEL_EXPR}.
@code{CASE_LABEL_EXPR}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree default_label, @code{VEC}(tree,heap) *args)
@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}
This function is an alternate way of building @code{GIMPLE_SWITCH}
statements.  @code{INDEX} and @code{DEFAULT_LABEL} are as in
statements.  @code{INDEX} and @code{DEFAULT_LABEL} are as in
gimple_build_switch.  @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees
gimple_build_switch.  @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees
that contain the labels.
that contain the labels.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
Return the number of labels associated with the switch statement
Return the number of labels associated with the switch statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, unsigned nlabels)
@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
Set @code{NLABELS} to be the number of labels for the switch statement
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
Return the index variable used by the switch statement @code{G}.
Return the index variable used by the switch statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
@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}.
Set @code{INDEX} to be the index variable for switch statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
Return the label numbered @code{INDEX}. The default label is 0, followed
Return the label numbered @code{INDEX}. The default label is 0, followed
by any labels in a switch statement.
by any labels in a switch statement.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned index, tree label)
@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
Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
label.
label.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
Return the default label for a switch statement.
Return the default label for a switch statement.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, tree label)
@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, tree label)
Set the default label for a switch statement.
Set the default label for a switch statement.
@end deftypefn
@end deftypefn
 
 
 
 
@node @code{GIMPLE_TRY}
@node @code{GIMPLE_TRY}
@subsection @code{GIMPLE_TRY}
@subsection @code{GIMPLE_TRY}
@cindex @code{GIMPLE_TRY}
@cindex @code{GIMPLE_TRY}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, gimple_seq cleanup, unsigned int kind)
@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
Build a @code{GIMPLE_TRY} statement.  @code{EVAL} is a sequence with the
expression to evaluate.  @code{CLEANUP} is a sequence of statements to
expression to evaluate.  @code{CLEANUP} is a sequence of statements to
run at clean-up time.  @code{KIND} is the enumeration value
run at clean-up time.  @code{KIND} is the enumeration value
@code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
@code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
construct.
construct.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} enum gimple_try_flags gimple_try_kind (gimple g)
@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
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}.
either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
Return the sequence of statements used as the body for @code{GIMPLE_TRY}
Return the sequence of statements used as the body for @code{GIMPLE_TRY}
@code{G}.
@code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
Return the sequence of statements used as the cleanup body for
Return the sequence of statements used as the cleanup body for
@code{GIMPLE_TRY} @code{G}.
@code{GIMPLE_TRY} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
@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.
Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
@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
Set @code{EVAL} to be the sequence of statements to use as the body for
@code{GIMPLE_TRY} @code{G}.
@code{GIMPLE_TRY} @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
@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
Set @code{CLEANUP} to be the sequence of statements to use as the
cleanup body for @code{GIMPLE_TRY} @code{G}.
cleanup body for @code{GIMPLE_TRY} @code{G}.
@end deftypefn
@end deftypefn
 
 
@node @code{GIMPLE_WITH_CLEANUP_EXPR}
@node @code{GIMPLE_WITH_CLEANUP_EXPR}
@subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
@subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
@cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
@cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
 
 
@deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
@deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @code{CLEANUP} is the
Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @code{CLEANUP} is the
clean-up expression.
clean-up expression.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
Return the cleanup sequence for cleanup statement @code{G}.
Return the cleanup sequence for cleanup statement @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
@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.
Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn
@end deftypefn
 
 
 
 
@node GIMPLE sequences
@node GIMPLE sequences
@section GIMPLE sequences
@section GIMPLE sequences
@cindex GIMPLE sequences
@cindex GIMPLE sequences
 
 
GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
used in @code{GENERIC}.  They are used to chain statements together, and
used in @code{GENERIC}.  They are used to chain statements together, and
when used in conjunction with sequence iterators, provide a
when used in conjunction with sequence iterators, provide a
framework for iterating through statements.
framework for iterating through statements.
 
 
GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
commonly passed by reference to functions dealing with sequences.
commonly passed by reference to functions dealing with sequences.
The type for a sequence pointer is @code{gimple_seq} which is the same
The type for a sequence pointer is @code{gimple_seq} which is the same
as struct @code{gimple_sequence} *.  When declaring a local sequence,
as struct @code{gimple_sequence} *.  When declaring a local sequence,
you can define a local variable of type struct @code{gimple_sequence}.
you can define a local variable of type struct @code{gimple_sequence}.
When declaring a sequence allocated on the garbage collected
When declaring a sequence allocated on the garbage collected
heap, use the function @code{gimple_seq_alloc} documented below.
heap, use the function @code{gimple_seq_alloc} documented below.
 
 
There are convenience functions for iterating through sequences
There are convenience functions for iterating through sequences
in the section entitled Sequence Iterators.
in the section entitled Sequence Iterators.
 
 
Below is a list of functions to manipulate and query sequences.
Below is a list of functions to manipulate and query sequences.
 
 
@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
@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
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.
not @code{NULL}.  If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
@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
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
@code{NULL}.  If *@code{DEST} is @code{NULL}, allocate a new sequence before
appending.
appending.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
@deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
Perform a deep copy of sequence @code{SRC} and return the result.
Perform a deep copy of sequence @code{SRC} and return the result.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
@deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
Reverse the order of the statements in the sequence @code{SEQ}.  Return
Reverse the order of the statements in the sequence @code{SEQ}.  Return
@code{SEQ}.
@code{SEQ}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
@deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
Return the first statement in sequence @code{S}.
Return the first statement in sequence @code{S}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
@deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
Return the last statement in sequence @code{S}.
Return the last statement in sequence @code{S}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
@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}.
Set the last statement in sequence @code{S} to the statement in @code{LAST}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
@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}.
Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
@deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
Initialize sequence @code{S} to an empty sequence.
Initialize sequence @code{S} to an empty sequence.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
@deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
Allocate a new sequence in the garbage collected store and return
Allocate a new sequence in the garbage collected store and return
it.
it.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
@deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
Copy the sequence @code{SRC} into the sequence @code{DEST}.
Copy the sequence @code{SRC} into the sequence @code{DEST}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
@deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
Return true if the sequence @code{S} is empty.
Return true if the sequence @code{S} is empty.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
@deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
Returns the sequence of statements in @code{BB}.
Returns the sequence of statements in @code{BB}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
@deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
Sets the sequence of statements in @code{BB} to @code{SEQ}.
Sets the sequence of statements in @code{BB} to @code{SEQ}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
@deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
Determine whether @code{SEQ} contains exactly one statement.
Determine whether @code{SEQ} contains exactly one statement.
@end deftypefn
@end deftypefn
 
 
@node Sequence iterators
@node Sequence iterators
@section Sequence iterators
@section Sequence iterators
@cindex Sequence iterators
@cindex Sequence iterators
 
 
Sequence iterators are convenience constructs for iterating
Sequence iterators are convenience constructs for iterating
through statements in a sequence.  Given a sequence @code{SEQ}, here is
through statements in a sequence.  Given a sequence @code{SEQ}, here is
a typical use of gimple sequence iterators:
a typical use of gimple sequence iterators:
 
 
@smallexample
@smallexample
gimple_stmt_iterator gsi;
gimple_stmt_iterator gsi;
 
 
for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
  @{
  @{
    gimple g = gsi_stmt (gsi);
    gimple g = gsi_stmt (gsi);
    /* Do something with gimple statement @code{G}.  */
    /* Do something with gimple statement @code{G}.  */
  @}
  @}
@end smallexample
@end smallexample
 
 
Backward iterations are possible:
Backward iterations are possible:
 
 
@smallexample
@smallexample
        for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
        for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
@end smallexample
@end smallexample
 
 
Forward and backward iterations on basic blocks are possible with
Forward and backward iterations on basic blocks are possible with
@code{gsi_start_bb} and @code{gsi_last_bb}.
@code{gsi_start_bb} and @code{gsi_last_bb}.
 
 
In the documentation below we sometimes refer to enum
In the documentation below we sometimes refer to enum
@code{gsi_iterator_update}.  The valid options for this enumeration are:
@code{gsi_iterator_update}.  The valid options for this enumeration are:
 
 
@itemize @bullet
@itemize @bullet
@item @code{GSI_NEW_STMT}
@item @code{GSI_NEW_STMT}
Only valid when a single statement is added.  Move the iterator to it.
Only valid when a single statement is added.  Move the iterator to it.
 
 
@item @code{GSI_SAME_STMT}
@item @code{GSI_SAME_STMT}
Leave the iterator at the same statement.
Leave the iterator at the same statement.
 
 
@item @code{GSI_CONTINUE_LINKING}
@item @code{GSI_CONTINUE_LINKING}
Move iterator to whatever position is suitable for linking other
Move iterator to whatever position is suitable for linking other
statements in the same direction.
statements in the same direction.
@end itemize
@end itemize
 
 
Below is a list of the functions used to manipulate and use
Below is a list of the functions used to manipulate and use
statement iterators.
statement iterators.
 
 
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
Return a new iterator pointing to the sequence @code{SEQ}'s first
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}.
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
Use @code{gsi_start_bb} instead when the iterator needs to always have
the correct basic block set.
the correct basic block set.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
Return a new iterator pointing to the first statement in basic
Return a new iterator pointing to the first statement in basic
block @code{BB}.
block @code{BB}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
Return a new iterator initially pointing to the last statement of
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
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
@code{NULL}.  Use @code{gsi_last_bb} instead when the iterator needs to always
have the correct basic block set.
have the correct basic block set.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
Return a new iterator pointing to the last statement in basic
Return a new iterator pointing to the last statement in basic
block @code{BB}.
block @code{BB}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
@deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
Return @code{TRUE} if at the end of @code{I}.
Return @code{TRUE} if at the end of @code{I}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
@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}.
Return @code{TRUE} if we're one statement before the end of @code{I}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
@deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
Advance the iterator to the next gimple statement.
Advance the iterator to the next gimple statement.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
@deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
Advance the iterator to the previous gimple statement.
Advance the iterator to the previous gimple statement.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
@deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
Return the current stmt.
Return the current stmt.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb)
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb)
Return a block statement iterator that points to the first
Return a block statement iterator that points to the first
non-label statement in block @code{BB}.
non-label statement in block @code{BB}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple *gsi_stmt_ptr (gimple_stmt_iterator *i)
@deftypefn {GIMPLE function} gimple *gsi_stmt_ptr (gimple_stmt_iterator *i)
Return a pointer to the current stmt.
Return a pointer to the current stmt.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
@deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
Return the basic block associated with this iterator.
Return the basic block associated with this iterator.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
@deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
Return the sequence associated with this iterator.
Return the sequence associated with this iterator.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
@deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
Remove the current stmt from the sequence.  The iterator is
Remove the current stmt from the sequence.  The iterator is
updated to point to the next statement.  When @code{REMOVE_EH_INFO} 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}
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,
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
@code{REMOVE_EH_INFO} should be true when the statement is going to be
removed from the @code{IL} and not reinserted elsewhere.
removed from the @code{IL} and not reinserted elsewhere.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
@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
Links the sequence of statements @code{SEQ} before the statement pointed
by iterator @code{I}.  @code{MODE} indicates what to do with the iterator
by iterator @code{I}.  @code{MODE} indicates what to do with the iterator
after insertion (see @code{enum gsi_iterator_update} above).
after insertion (see @code{enum gsi_iterator_update} above).
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
@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}.
Links statement @code{G} before the statement pointed-to by iterator @code{I}.
Updates iterator @code{I} according to @code{MODE}.
Updates iterator @code{I} according to @code{MODE}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
@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}.
Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
@code{MODE} is as in @code{gsi_insert_after}.
@code{MODE} is as in @code{gsi_insert_after}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
@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}.
Links statement @code{G} after the statement pointed-to by iterator @code{I}.
@code{MODE} is as in @code{gsi_insert_after}.
@code{MODE} is as in @code{gsi_insert_after}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
@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.
Move all statements in the sequence after @code{I} to a new sequence.
Return this new sequence.
Return this new sequence.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
@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.
Move all statements in the sequence before @code{I} to a new sequence.
Return this new sequence.
Return this new sequence.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, gimple stmt, bool update_eh_info)
@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}
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
is true, the exception handling information of the original
statement is moved to the new statement.
statement is moved to the new statement.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
@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
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}
@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
specifies how to update iterator @code{I} after insertion (see enum
@code{gsi_iterator_update}).
@code{gsi_iterator_update}).
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
@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}.
Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
@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
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}
@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
specifies how to update iterator @code{I} after insertion (see enum
@code{gsi_iterator_update}).
@code{gsi_iterator_update}).
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
@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}.
Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
Finds iterator for @code{STMT}.
Finds iterator for @code{STMT}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
@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
Move the statement at @code{FROM} so it comes right after the statement
at @code{TO}.
at @code{TO}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
@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
Move the statement at @code{FROM} so it comes right before the statement
at @code{TO}.
at @code{TO}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
@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}.
Move the statement at @code{FROM} to the end of basic block @code{BB}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
@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
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.
made until a call to @code{gsi_commit_edge_inserts}() is made.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
@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
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{E}.  No actual insertion is made until a call to
@code{gsi_commit_edge_inserts}() is made.
@code{gsi_commit_edge_inserts}() is made.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
@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
Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}.  If a new
block has to be created, it is returned.
block has to be created, it is returned.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
@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,
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}.
set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
@end deftypefn
@end deftypefn
 
 
@deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
@deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
This routine will commit all pending edge insertions, creating
This routine will commit all pending edge insertions, creating
any new basic blocks which are necessary.
any new basic blocks which are necessary.
@end deftypefn
@end deftypefn
 
 
 
 
@node Adding a new GIMPLE statement code
@node Adding a new GIMPLE statement code
@section Adding a new GIMPLE statement code
@section Adding a new GIMPLE statement code
@cindex Adding a new GIMPLE statement code
@cindex Adding a new GIMPLE statement code
 
 
The first step in adding a new GIMPLE statement code, is
The first step in adding a new GIMPLE statement code, is
modifying the file @code{gimple.def}, which contains all the GIMPLE
modifying the file @code{gimple.def}, which contains all the GIMPLE
codes.  Then you must add a corresponding structure, and an entry
codes.  Then you must add a corresponding structure, and an entry
in @code{union gimple_statement_d}, both of which are located in
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{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{GTY} tag in @code{gsstruct.def}, and code to handle this tag in
@code{gss_for_code} which is located in @code{gimple.c}.
@code{gss_for_code} which is located in @code{gimple.c}.
 
 
In order for the garbage collector to know the size of the
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
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
handle your new GIMPLE statement in @code{gimple_size} which is located
in @code{gimple.c}.
in @code{gimple.c}.
 
 
You will probably want to create a function to build the new
You will probably want to create a function to build the new
gimple statement in @code{gimple.c}.  The function should be called
gimple statement in @code{gimple.c}.  The function should be called
@code{gimple_build_<@code{NEW_TUPLE_NAME}>}, and should return the new tuple
@code{gimple_build_<@code{NEW_TUPLE_NAME}>}, and should return the new tuple
of type gimple.
of type gimple.
 
 
If your new statement requires accessors for any members or
If your new statement requires accessors for any members or
operands it may have, put simple inline accessors in
operands it may have, put simple inline accessors in
@code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
@code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
corresponding prototype in @code{gimple.h}.
corresponding prototype in @code{gimple.h}.
 
 
 
 
@node Statement and operand traversals
@node Statement and operand traversals
@section Statement and operand traversals
@section Statement and operand traversals
@cindex Statement and operand traversals
@cindex Statement and operand traversals
 
 
There are two functions available for walking statements and
There are two functions available for walking statements and
sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
accordingly, and a third function for walking the operands in a
accordingly, and a third function for walking the operands in a
statement: @code{walk_gimple_op}.
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)
@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},
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
optionally using traversal state stored in @code{WI}.  If @code{WI} is @code{NULL}, no
state is kept during the traversal.
state is kept during the traversal.
 
 
The callback @code{CALLBACK_STMT} is called.  If @code{CALLBACK_STMT} returns
The callback @code{CALLBACK_STMT} is called.  If @code{CALLBACK_STMT} returns
true, it means that the callback function has handled all the
true, it means that the callback function has handled all the
operands of the statement and it is not necessary to walk its
operands of the statement and it is not necessary to walk its
operands.
operands.
 
 
If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
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
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
@code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
operands are not scanned.
operands are not scanned.
 
 
The return value is that returned by the last call to
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.
@code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
@end deftypefn
@end deftypefn
 
 
 
 
@deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
@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
Use this function to walk the operands of statement @code{STMT}.  Every
operand is walked via @code{walk_tree} with optional state information
operand is walked via @code{walk_tree} with optional state information
in @code{WI}.
in @code{WI}.
 
 
@code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
@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
Additional parameters to @code{walk_tree} must be stored in @code{WI}.  For
each operand @code{OP}, @code{walk_tree} is called as:
each operand @code{OP}, @code{walk_tree} is called as:
 
 
@smallexample
@smallexample
    walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{WI}- @code{PSET})
    walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{WI}- @code{PSET})
@end smallexample
@end smallexample
 
 
If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
operands are not scanned.  The return value is that returned by
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
the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
specified.
specified.
@end deftypefn
@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)
@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}
This function walks all the statements in the sequence @code{SEQ}
calling @code{walk_gimple_stmt} on each one.  @code{WI} is as in
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
@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
is stopped and the value returned.  Otherwise, all the statements
are walked and @code{NULL_TREE} returned.
are walked and @code{NULL_TREE} returned.
@end deftypefn
@end deftypefn
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.