-@c Copyright (c) 2008, 2009 Free Software Foundation, Inc.
+@c Copyright (C) 2008-2023 Free Software Foundation, Inc.
@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@menu
* Tuple representation::
+* Class hierarchy of GIMPLE statements::
* GIMPLE instruction set::
* GIMPLE Exception Handling::
* Temporaries::
and a variable length body with all the operands. Tuples are
organized into a hierarchy with 3 main classes of tuples.
-@subsection @code{gimple_statement_base} (gsbase)
-@cindex gimple_statement_base
+@subsection @code{gimple} (gsbase)
+@cindex gimple
This is the root of the hierarchy, it holds basic information
needed by most GIMPLE statements. There are some fields that
@itemize @bullet
@item @code{code}
-Main identifier for a GIMPLE instruction.
+Main identifier for a GIMPLE instruction.
@item @code{subcode}
Used to distinguish different variants of the same basic
@item @code{bb}
Basic block holding the instruction.
-
+
@item @code{block}
Lexical block holding this statement. Also used for debug
information generation.
is then inherited from the other two tuples.
-@multitable {@code{addresses_taken}} {56 + 8 * @code{num_ops} bytes}
+@multitable {@code{def_ops}} {48 + 8 * @code{num_ops} bytes}
@item @code{gsbase} @tab 256
-@item @code{addresses_taken} @tab 64
@item @code{def_ops} @tab 64
@item @code{use_ops} @tab 64
@item @code{op} @tab @code{num_ops} * 64
-@item Total size @tab 56 + 8 * @code{num_ops} bytes
+@item Total size @tab 48 + 8 * @code{num_ops} bytes
@end multitable
@itemize @bullet
@item @code{gsbase}
-Inherited from @code{struct gimple_statement_base}.
-
-@item @code{addresses_taken}
-Bitmap holding the UIDs of all the @code{VAR_DECL}s whose addresses are
-taken by this statement. For example, a statement of the form
-@code{p = &b} will have the UID for symbol @code{b} in this set.
+Inherited from @code{struct gimple}.
@item @code{def_ops}
Array of pointers into the operand array indicating all the slots that
@code{gimple_statement_with_memory_ops}).
-@multitable {@code{addresses_taken}} {88 + 8 * @code{num_ops} bytes}
-@item Field @tab Size (bits)
-@item @code{gsbase} @tab 256
-@item @code{addresses_taken} @tab 64
-@item @code{def_ops} @tab 64
-@item @code{use_ops} @tab 64
-@item @code{vdef_ops} @tab 64
-@item @code{vuse_ops} @tab 64
-@item @code{stores} @tab 64
-@item @code{loads} @tab 64
-@item @code{op} @tab @code{num_ops} * 64
-@item Total size @tab 88 + 8 * @code{num_ops} bytes
+@multitable {@code{vdef_ops}} {80 + 8 * @code{num_ops} bytes}
+@item Field @tab Size (bits)
+@item @code{gsbase} @tab 256
+@item @code{def_ops} @tab 64
+@item @code{use_ops} @tab 64
+@item @code{vdef_ops} @tab 64
+@item @code{vuse_ops} @tab 64
+@item @code{stores} @tab 64
+@item @code{loads} @tab 64
+@item @code{op} @tab @code{num_ops} * 64
+@item Total size @tab 80 + 8 * @code{num_ops} bytes
@end multitable
@itemize @bullet
@end itemize
All the other tuples are defined in terms of these three basic
-ones. Each tuple will add some fields. The main gimple type
-is defined to be the union of all these structures (@code{GTY} markers
-elided for clarity):
+ones. Each tuple will add some fields.
+
+
+@node Class hierarchy of GIMPLE statements
+@section Class hierarchy of GIMPLE statements
+@cindex GIMPLE class hierarchy
+
+The following diagram shows the C++ inheritance hierarchy of statement
+kinds, along with their relationships to @code{GSS_} values (layouts) and
+@code{GIMPLE_} values (codes):
@smallexample
-union gimple_statement_d
-@{
- struct gimple_statement_base gsbase;
- struct gimple_statement_with_ops gsops;
- struct gimple_statement_with_memory_ops gsmem;
- struct gimple_statement_omp omp;
- struct gimple_statement_bind gimple_bind;
- struct gimple_statement_catch gimple_catch;
- struct gimple_statement_eh_filter gimple_eh_filter;
- struct gimple_statement_phi gimple_phi;
- struct gimple_statement_resx gimple_resx;
- struct gimple_statement_try gimple_try;
- struct gimple_statement_wce gimple_wce;
- struct gimple_statement_asm gimple_asm;
- struct gimple_statement_omp_critical gimple_omp_critical;
- struct gimple_statement_omp_for gimple_omp_for;
- struct gimple_statement_omp_parallel gimple_omp_parallel;
- struct gimple_statement_omp_task gimple_omp_task;
- struct gimple_statement_omp_sections gimple_omp_sections;
- struct gimple_statement_omp_single gimple_omp_single;
- struct gimple_statement_omp_continue gimple_omp_continue;
- struct gimple_statement_omp_atomic_load gimple_omp_atomic_load;
- struct gimple_statement_omp_atomic_store gimple_omp_atomic_store;
-@};
+ gimple
+ | layout: GSS_BASE
+ | used for 4 codes: GIMPLE_ERROR_MARK
+ | GIMPLE_NOP
+ | GIMPLE_OMP_SECTIONS_SWITCH
+ | GIMPLE_PREDICT
+ |
+ + gimple_statement_with_ops_base
+ | | (no GSS layout)
+ | |
+ | + gimple_statement_with_ops
+ | | | layout: GSS_WITH_OPS
+ | | |
+ | | + gcond
+ | | | code: GIMPLE_COND
+ | | |
+ | | + gdebug
+ | | | code: GIMPLE_DEBUG
+ | | |
+ | | + ggoto
+ | | | code: GIMPLE_GOTO
+ | | |
+ | | + glabel
+ | | | code: GIMPLE_LABEL
+ | | |
+ | | + gswitch
+ | | code: GIMPLE_SWITCH
+ | |
+ | + gimple_statement_with_memory_ops_base
+ | | layout: GSS_WITH_MEM_OPS_BASE
+ | |
+ | + gimple_statement_with_memory_ops
+ | | | layout: GSS_WITH_MEM_OPS
+ | | |
+ | | + gassign
+ | | | code GIMPLE_ASSIGN
+ | | |
+ | | + greturn
+ | | code GIMPLE_RETURN
+ | |
+ | + gcall
+ | | layout: GSS_CALL, code: GIMPLE_CALL
+ | |
+ | + gasm
+ | | layout: GSS_ASM, code: GIMPLE_ASM
+ | |
+ | + gtransaction
+ | layout: GSS_TRANSACTION, code: GIMPLE_TRANSACTION
+ |
+ + gimple_statement_omp
+ | | layout: GSS_OMP. Used for code GIMPLE_OMP_SECTION
+ | |
+ | + gomp_critical
+ | | layout: GSS_OMP_CRITICAL, code: GIMPLE_OMP_CRITICAL
+ | |
+ | + gomp_for
+ | | layout: GSS_OMP_FOR, code: GIMPLE_OMP_FOR
+ | |
+ | + gomp_parallel_layout
+ | | | layout: GSS_OMP_PARALLEL_LAYOUT
+ | | |
+ | | + gimple_statement_omp_taskreg
+ | | | |
+ | | | + gomp_parallel
+ | | | | code: GIMPLE_OMP_PARALLEL
+ | | | |
+ | | | + gomp_task
+ | | | code: GIMPLE_OMP_TASK
+ | | |
+ | | + gimple_statement_omp_target
+ | | code: GIMPLE_OMP_TARGET
+ | |
+ | + gomp_sections
+ | | layout: GSS_OMP_SECTIONS, code: GIMPLE_OMP_SECTIONS
+ | |
+ | + gimple_statement_omp_single_layout
+ | | layout: GSS_OMP_SINGLE_LAYOUT
+ | |
+ | + gomp_single
+ | | code: GIMPLE_OMP_SINGLE
+ | |
+ | + gomp_teams
+ | code: GIMPLE_OMP_TEAMS
+ |
+ + gbind
+ | layout: GSS_BIND, code: GIMPLE_BIND
+ |
+ + gcatch
+ | layout: GSS_CATCH, code: GIMPLE_CATCH
+ |
+ + geh_filter
+ | layout: GSS_EH_FILTER, code: GIMPLE_EH_FILTER
+ |
+ + geh_else
+ | layout: GSS_EH_ELSE, code: GIMPLE_EH_ELSE
+ |
+ + geh_mnt
+ | layout: GSS_EH_MNT, code: GIMPLE_EH_MUST_NOT_THROW
+ |
+ + gphi
+ | layout: GSS_PHI, code: GIMPLE_PHI
+ |
+ + gimple_statement_eh_ctrl
+ | | layout: GSS_EH_CTRL
+ | |
+ | + gresx
+ | | code: GIMPLE_RESX
+ | |
+ | + geh_dispatch
+ | code: GIMPLE_EH_DISPATCH
+ |
+ + gtry
+ | layout: GSS_TRY, code: GIMPLE_TRY
+ |
+ + gimple_statement_wce
+ | layout: GSS_WCE, code: GIMPLE_WITH_CLEANUP_EXPR
+ |
+ + gomp_continue
+ | layout: GSS_OMP_CONTINUE, code: GIMPLE_OMP_CONTINUE
+ |
+ + gomp_atomic_load
+ | layout: GSS_OMP_ATOMIC_LOAD, code: GIMPLE_OMP_ATOMIC_LOAD
+ |
+ + gimple_statement_omp_atomic_store_layout
+ | layout: GSS_OMP_ATOMIC_STORE_LAYOUT,
+ | code: GIMPLE_OMP_ATOMIC_STORE
+ |
+ + gomp_atomic_store
+ | code: GIMPLE_OMP_ATOMIC_STORE
+ |
+ + gomp_return
+ code: GIMPLE_OMP_RETURN
@end smallexample
-
+
@node GIMPLE instruction set
@section GIMPLE instruction set
@cindex GIMPLE instruction set
@item @code{GIMPLE_CALL} @tab x @tab x
@item @code{GIMPLE_CATCH} @tab x @tab
@item @code{GIMPLE_COND} @tab x @tab x
+@item @code{GIMPLE_DEBUG} @tab x @tab x
@item @code{GIMPLE_EH_FILTER} @tab x @tab
@item @code{GIMPLE_GOTO} @tab x @tab x
@item @code{GIMPLE_LABEL} @tab x @tab x
Currently, an expression like @code{a = b + 5} is not reduced any
further. We tried converting it to something like
@smallexample
- T1 = b + 5;
- a = T1;
+T1 = b + 5;
+a = T1;
@end smallexample
but this bloated the representation for minimal benefit. However, a
variable which must live in memory cannot appear in an expression; its
variable. More complex operands are factored out into temporaries, so
that
@smallexample
- a = b + c + d
+a = b + c + d
@end smallexample
becomes
@smallexample
- T1 = b + c;
- a = T1 + d;
+T1 = b + c;
+a = T1 + d;
@end smallexample
The same rule holds for arguments to a @code{GIMPLE_CALL}.
-The target of an assignment is usually a variable, but can also be an
-@code{INDIRECT_REF} or a compound lvalue as described below.
+The target of an assignment is usually a variable, but can also be a
+@code{MEM_REF} or a compound lvalue as described below.
@menu
* Compound Expressions::
to
@smallexample
- T1 = &a.b;
- T1[2] = 42;
+T1 = &a.b;
+T1[2] = 42;
@end smallexample
alias analysis would not remember that the reference to @code{T1[2]} came
each branch assigning to the same temporary. So,
@smallexample
- a = b ? c : d;
+a = b ? c : d;
@end smallexample
becomes
@smallexample
- if (b == 1)
- T1 = c;
- else
- T1 = d;
- a = T1;
+if (b == 1)
+ T1 = c;
+else
+ T1 = d;
+a = T1;
@end smallexample
The GIMPLE level if-conversion pass re-introduces @code{?:}
as follows: @code{a = b && c} becomes
@smallexample
- T1 = (bool)b;
- if (T1 == true)
- T1 = (bool)c;
- a = T1;
+T1 = (bool)b;
+if (T1 == true)
+ T1 = (bool)c;
+a = T1;
@end smallexample
Note that @code{T1} in this example cannot be an expression temporary,
@item @code{GIMPLE_INVALID_RHS}
The tree cannot be used as a GIMPLE operand.
+@item @code{GIMPLE_TERNARY_RHS}
+The tree is a valid GIMPLE ternary operation.
+
@item @code{GIMPLE_BINARY_RHS}
The tree is a valid GIMPLE binary operation.
expression of the form @code{(a op b) ? x : y} could be flattened
out on the operand vector using 4 slots, but it would also
require additional processing to distinguish @code{c = a op b}
-from @code{c = a op b ? x : y}. Something similar occurs with
-@code{ASSERT_EXPR}. In time, these special case tree
+from @code{c = a op b ? x : y}. In time, these special case tree
expressions should be flattened into the operand vector.
@end itemize
-For tree nodes in the categories @code{GIMPLE_BINARY_RHS} and
-@code{GIMPLE_UNARY_RHS}, they cannot be stored inside tuples directly.
-They first need to be flattened and separated into individual
-components. For instance, given the GENERIC expression
+For tree nodes in the categories @code{GIMPLE_TERNARY_RHS},
+@code{GIMPLE_BINARY_RHS} and @code{GIMPLE_UNARY_RHS}, they cannot be
+stored inside tuples directly. They first need to be flattened and
+separated into individual components. For instance, given the GENERIC
+expression
@smallexample
a = b + c
Returns operand @code{I} from statement @code{G}.
@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
is computed using an internal table called @code{gimple_ops_offset_}[].
This table is indexed by the gimple code of @code{G}.
When adding a new operand to a gimple statement, the operand will
be validated according to what each tuple accepts in its operand
vector. These predicates are called by the
-@code{gimple_<name>_set_...()}. Each tuple will use one of the
+@code{gimple_@var{name}_set_...()}. Each tuple will use one of the
following predicates (Note, this list is not exhaustive):
-@deftypefn {GIMPLE function} is_gimple_operand (tree t)
-This is the most permissive of the predicates. It essentially
-checks whether t has a @code{gimple_rhs_class} of @code{GIMPLE_SINGLE_RHS}.
-@end deftypefn
-
-
-@deftypefn {GIMPLE function} is_gimple_val (tree t)
+@deftypefn {GIMPLE function} bool is_gimple_val (tree t)
Returns true if t is a "GIMPLE value", which are all the
non-addressable stack variables (variables for which
@code{is_gimple_reg} returns true) and constants (expressions for which
@code{is_gimple_min_invariant} returns true).
@end deftypefn
-@deftypefn {GIMPLE function} is_gimple_addressable (tree t)
+@deftypefn {GIMPLE function} bool is_gimple_addressable (tree t)
Returns true if t is a symbol or memory reference whose address
can be taken.
@end deftypefn
-@deftypefn {GIMPLE function} is_gimple_asm_val (tree t)
+@deftypefn {GIMPLE function} bool is_gimple_asm_val (tree t)
Similar to @code{is_gimple_val} but it also accepts hard registers.
@end deftypefn
-@deftypefn {GIMPLE function} is_gimple_call_addr (tree t)
+@deftypefn {GIMPLE function} bool is_gimple_call_addr (tree t)
Return true if t is a valid expression to use as the function
called by a @code{GIMPLE_CALL}.
@end deftypefn
-@deftypefn {GIMPLE function} is_gimple_constant (tree t)
+@deftypefn {GIMPLE function} bool is_gimple_mem_ref_addr (tree t)
+Return true if t is a valid expression to use as first operand
+of a @code{MEM_REF} expression.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool is_gimple_constant (tree t)
Return true if t is a valid gimple constant.
@end deftypefn
-@deftypefn {GIMPLE function} is_gimple_min_invariant (tree t)
+@deftypefn {GIMPLE function} bool is_gimple_min_invariant (tree t)
Return true if t is a valid minimal invariant. This is different
from constants, in that the specific value of t may not be known
at compile time, but it is known that it doesn't change (e.g.,
the address of a function local variable).
@end deftypefn
-@deftypefn {GIMPLE function} is_gimple_min_invariant_address (tree t)
+@deftypefn {GIMPLE function} bool is_gimple_ip_invariant (tree t)
+Return true if t is an interprocedural invariant. This means that t
+is a valid invariant in all functions (e.g.@: it can be an address of a
+global variable but not of a local one).
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool is_gimple_ip_invariant_address (tree t)
Return true if t is an @code{ADDR_EXPR} that does not change once the
-program is running.
+program is running (and which is valid in all functions).
@end deftypefn
@subsection Statement validation
-@deftypefn {GIMPLE function} is_gimple_assign (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
Return true if the code of g is @code{GIMPLE_ASSIGN}.
@end deftypefn
-
-@deftypefn {GIMPLE function} is_gimple_call (gimple g)
+
+@deftypefn {GIMPLE function} bool is_gimple_call (gimple g)
Return true if the code of g is @code{GIMPLE_CALL}.
@end deftypefn
-
-@deftypefn {GIMPLE function} is_gimple_debug (gimple g)
+
+@deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)
Return true if the code of g is @code{GIMPLE_DEBUG}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_assign_cast_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple g)
Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
operation.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_debug_bind_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g)
Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
expression to a variable.
@end deftypefn
+@deftypefn {GIMPLE function} bool is_gimple_omp (gimple g)
+Return true if g is any of the OpenMP codes.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_debug_begin_stmt_p (gimple g)
+Return true if g is a @code{GIMPLE_DEBUG} that marks the beginning of
+a source statement.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_debug_inline_entry_p (gimple g)
+Return true if g is a @code{GIMPLE_DEBUG} that marks the entry
+point of an inlined function.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_debug_nonbind_marker_p (gimple g)
+Return true if g is a @code{GIMPLE_DEBUG} that marks a program location,
+without any variable binding.
+@end deftypefn
+
@node Manipulating GIMPLE statements
@section Manipulating GIMPLE statements
@cindex Manipulating GIMPLE statements
This section documents all the functions available to handle each
of the GIMPLE instructions.
-@subsection Common accessors
+@subsection Common accessors
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}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
Return the basic block to which statement @code{G} belongs to.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_block (gimple g)
Return the lexical scope block holding statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
-Return the type of the main expression computed by @code{STMT}. Return
-@code{void_type_node} if @code{STMT} computes nothing. This will only return
-something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
-@code{GIMPLE_CALL}. For all other tuple codes, it will return
-@code{void_type_node}.
-@end deftypefn
-@deftypefn {GIMPLE function} enum tree_code gimple_expr_code (gimple stmt)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
Return the tree code for the expression computed by @code{STMT}. This
is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
@code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
Set the lexical scope block of @code{G} to @code{BLOCK}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
Return locus information for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
Set locus information for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
Return true if @code{G} does not have locus information.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
Return true if no warnings should be emitted for statement @code{STMT}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
Set the visited status on statement @code{STMT} to @code{VISITED_P}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
Return the visited status on statement @code{STMT}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
@end deftypefn
-
-@deftypefn {GIMPLE function} unsigned int gimple_plf (gimple stmt, enum plf_mask plf)
+
+@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
Return the value of pass local flag @code{PLF} on statement @code{STMT}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
Return true if statement @code{G} has register or memory operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
Return true if statement @code{G} has memory operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
Return the number of operands for statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
+
+@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
Return the array of operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
Return operand @code{I} for statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_op_ptr (gimple g, unsigned i)
+
+@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
Return a pointer to operand @code{I} for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
Set operand @code{I} of statement @code{G} to @code{OP}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
Return the set of symbols that have had their address taken by
@code{STMT}.
@end deftypefn
-
-@deftypefn {GIMPLE function} struct def_optype_d *gimple_def_ops (gimple g)
+
+@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
Return the set of @code{DEF} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} struct use_optype_d *gimple_use_ops (gimple g)
+
+@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
Return the set of @code{USE} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} struct voptype_d *gimple_vuse_ops (gimple g)
+
+@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
Return the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} struct voptype_d *gimple_vdef_ops (gimple g)
+
+@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
Return the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
Return the set of symbols loaded by statement @code{G}. Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
Return the set of symbols stored by statement @code{G}. Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
Return true if statement @code{G} has operands and the modified field
has been set.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void update_stmt (gimple s)
Mark statement @code{S} as modified, and update it.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
Update statement @code{S} if it has been marked modified.
@end deftypefn
-
+
@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
Return a deep copy of statement @code{STMT}.
@end deftypefn
* @code{GIMPLE_CALL}::
* @code{GIMPLE_CATCH}::
* @code{GIMPLE_COND}::
+* @code{GIMPLE_DEBUG}::
* @code{GIMPLE_EH_FILTER}::
* @code{GIMPLE_LABEL}::
+* @code{GIMPLE_GOTO}::
* @code{GIMPLE_NOP}::
* @code{GIMPLE_OMP_ATOMIC_LOAD}::
* @code{GIMPLE_OMP_ATOMIC_STORE}::
@subsection @code{GIMPLE_ASM}
@cindex @code{GIMPLE_ASM}
-@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
+@deftypefn {GIMPLE function} gasm *gimple_build_asm_vec ( @
+const char *string, vec<tree, va_gc> *inputs, @
+vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers, @
+vec<tree, va_gc> *labels)
Build a @code{GIMPLE_ASM} statement. This statement is used for
building in-line assembly constructs. @code{STRING} is the assembly
-code. @code{NINPUT} is the number of register inputs. @code{NOUTPUT} is the
-number of register outputs. @code{NCLOBBERS} is the number of clobbered
-registers. The rest of the arguments trees for each input,
-output, and clobbered registers.
-@end deftypefn
-
-@deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
-Identical to gimple_build_asm, but the arguments are passed in
-VECs.
+code. @code{INPUTS}, @code{OUTPUTS}, @code{CLOBBERS} and @code{LABELS}
+are the inputs, outputs, clobbered registers and labels.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_asm_ninputs (gimple g)
-Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (const gasm *g)
+Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_asm_noutputs (gimple g)
-Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (const gasm *g)
+Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_asm_nclobbers (gimple g)
-Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (const gasm *g)
+Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
-Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} tree gimple_asm_input_op (const gasm *g, @
+unsigned index)
+Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
-Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gasm *g, @
+unsigned index, tree in_op)
+Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
-Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} tree gimple_asm_output_op (const gasm *g, @
+unsigned index)
+Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
+@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gasm *g, @
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
-@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
-Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (const gasm *g, @
+unsigned index)
+Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
-Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
+@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gasm *g, @
+unsigned index, tree clobber_op)
+Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} const char *gimple_asm_string (gimple g)
+@deftypefn {GIMPLE function} {const char *} gimple_asm_string (const gasm *g)
Return the string representing the assembly instruction in
-@code{GIMPLE_ASM} @code{G}.
+@code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
-Return true if @code{G} is an asm statement marked volatile.
+@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (const gasm *g)
+Return true if @code{G} is an asm statement marked volatile.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
-Mark asm statement @code{G} as volatile.
-@end deftypefn
-
-@deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
-Remove volatile marker from asm statement @code{G}.
+@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gasm *g, @
+bool volatile_p)
+Mark asm statement @code{G} as volatile or non-volatile based on
+@code{VOLATILE_P}.
@end deftypefn
@node @code{GIMPLE_ASSIGN}
@subsection @code{GIMPLE_ASSIGN}
@cindex @code{GIMPLE_ASSIGN}
-@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gassign *gimple_build_assign (tree lhs, tree rhs)
Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue
passed in lhs. The right-hand side can be either a unary or
binary tree expression. The expression tree rhs will be
tuple. However, try to avoid building expression trees for the
sole purpose of calling this function. If you already have the
operands in separate trees, it is better to use
-@code{gimple_build_assign_with_ops}.
+@code{gimple_build_assign} with @code{enum tree_code} argument and separate
+arguments for each operand.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gassign *gimple_build_assign @
+(tree lhs, enum tree_code subcode, tree op1, tree op2, tree op3)
+This function is similar to two operand @code{gimple_build_assign},
+but is used to build a @code{GIMPLE_ASSIGN} statement when the operands of the
+right-hand side of the assignment are already split into
+different operands.
+
+The left-hand side is an lvalue passed in lhs. Subcode is the
+@code{tree_code} for the right-hand side of the assignment. Op1, op2 and op3
+are the operands.
@end deftypefn
+@deftypefn {GIMPLE function} gassign *gimple_build_assign @
+(tree lhs, enum tree_code subcode, tree op1, tree op2)
+Like the above 5 operand @code{gimple_build_assign}, but with the last
+argument @code{NULL} - this overload should not be used for
+@code{GIMPLE_TERNARY_RHS} assignments.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gassign *gimple_build_assign @
+(tree lhs, enum tree_code subcode, tree op1)
+Like the above 4 operand @code{gimple_build_assign}, but with the last
+argument @code{NULL} - this overload should be used only for
+@code{GIMPLE_UNARY_RHS} and @code{GIMPLE_SINGLE_RHS} assignments.
+@end deftypefn
@deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
-@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
-(enum tree_code subcode, tree lhs, tree op1, tree op2)
-This function is similar to @code{gimple_build_assign}, but is used to
-build a @code{GIMPLE_ASSIGN} statement when the operands of the
-right-hand side of the assignment are already split into
-different operands.
-
-The left-hand side is an lvalue passed in lhs. Subcode is the
-@code{tree_code} for the right-hand side of the assignment. Op1 and op2
-are the operands. If op2 is null, subcode must be a @code{tree_code}
-for a unary expression.
-@end deftypefn
-
-@deftypefn {GIMPLE function} enum tree_code gimple_assign_rhs_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
Return the code of the expression computed on the @code{RHS} of
assignment statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} enum gimple_rhs_class gimple_assign_rhs_class (gimple g)
+
+@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
Return the gimple rhs class of the code for the expression
computed on the rhs of assignment statement @code{G}. This will never
return @code{GIMPLE_INVALID_RHS}.
@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
Return the @code{LHS} of assignment statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_assign_lhs_ptr (gimple g)
+
+@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
Return a pointer to the @code{LHS} of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
Return the first operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_assign_rhs1_ptr (gimple g)
+
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
Return the address of the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
Return the second operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
+
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
Return the address of the second operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
+
+@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
+Return the third operand on the @code{RHS} of assignment statement @code{G}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
+Return the address of the third operand on the @code{RHS} of assignment
+statement @code{G}.
+@end deftypefn
+
@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
Set @code{RHS} to be the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
-Return the second operand on the @code{RHS} of assignment statement @code{G}.
-@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
-Return a pointer to the second operand on the @code{RHS} of assignment
-statement @code{G}.
-@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
Set @code{RHS} to be the second operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
+
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
+Set @code{RHS} to be the third operand on the @code{RHS} of assignment
+statement @code{G}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple s)
Return true if @code{S} is a type-cast assignment.
@end deftypefn
@subsection @code{GIMPLE_BIND}
@cindex @code{GIMPLE_BIND}
-@deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
+@deftypefn {GIMPLE function} gbind *gimple_build_bind (tree vars, @
+gimple_seq body)
Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
and a body of statements in sequence @code{BODY}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
-Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
+@deftypefn {GIMPLE function} tree gimple_bind_vars (const gbind *g)
+Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_set_vars (gbind *g, tree vars)
Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_append_vars (gbind *g, tree vars)
Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gbind *g)
Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_set_body (gbind *g, @
+gimple_seq seq)
Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
-Append a statement to the end of a @code{GIMPLE_BIND}'s body.
+@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gbind *gs, gimple stmt)
+Append a statement to the end of a @code{GIMPLE_BIND}'s body.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_add_seq (gbind *gs, @
+gimple_seq seq)
Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
body.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
+@deftypefn {GIMPLE function} tree gimple_bind_block (const gbind *g)
Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
-@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
+@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
+@deftypefn {GIMPLE function} void gimple_bind_set_block (gbind *g, tree block)
Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@subsection @code{GIMPLE_CALL}
@cindex @code{GIMPLE_CALL}
-@deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
+@deftypefn {GIMPLE function} gcall *gimple_build_call (tree fn, @
+unsigned nargs, ...)
Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN}
must be either a @code{FUNCTION_DECL} or a gimple call address as
determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
-Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments and the
-function are taken from the expression directly. This routine
-assumes that @code{call_expr} is already in GIMPLE form. That is, its
-operands are GIMPLE values and the function call needs no further
+@deftypefn {GIMPLE function} gcall *gimple_build_call_from_tree (tree call_expr, @
+tree fnptrtype)
+Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments
+and the function are taken from the expression directly. The type of the
+@code{GIMPLE_CALL} is set from the second parameter passed by a caller.
+This routine assumes that @code{call_expr} is already in GIMPLE form.
+That is, its operands are GIMPLE values and the function call needs no further
simplification. All the call flags in @code{call_expr} are copied over
to the new @code{GIMPLE_CALL}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
+@deftypefn {GIMPLE function} gcall *gimple_build_call_vec (tree fn, @
+@code{vec<tree>} args)
Identical to @code{gimple_build_call} but the arguments are stored in a
-@code{VEC}().
+@code{vec<tree>}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
Return the @code{LHS} of call statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_call_lhs_ptr (gimple g)
+
+@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
Return a pointer to the @code{LHS} of call statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
Return the tree node representing the function called by call
statement @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
+
+@deftypefn {GIMPLE function} void gimple_call_set_fn (gcall *g, tree fn)
Set @code{FN} to be the function called by call statement @code{G}. This has
to be a gimple value specifying the address of the called
function.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
Otherwise return @code{NULL}. This function is analogous to
@code{get_callee_fndecl} in @code{GENERIC}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
Set the called function to @code{FNDECL}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_return_type (const gcall *g)
Return the type returned by call statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
-Return the static chain for call statement @code{G}.
+Return the static chain for call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
-Set @code{CHAIN} to be the static chain for call statement @code{G}.
+@deftypefn {GIMPLE function} void gimple_call_set_chain (gcall *g, tree chain)
+Set @code{CHAIN} to be the static chain for call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_call_num_args (gimple g)
-Return the number of arguments used by call statement @code{G}.
+@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
+Return the number of arguments used by call statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
Return the argument at position @code{INDEX} for call statement @code{G}. The
first argument is 0.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_call_arg_ptr (gimple g, unsigned index)
+
+@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
Return a pointer to the argument at position @code{INDEX} for call
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
Set @code{ARG} to be the argument at position @code{INDEX} for call statement
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
+@deftypefn {GIMPLE function} void gimple_call_set_tail (gcall *s)
Mark call statement @code{S} as being a tail call (i.e., a call just
before the exit of a function). These calls are candidate for
-tail call optimization.
-@end deftypefn
-
-@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
-Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
-@end deftypefn
-
-@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
-Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
+tail call optimization.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
-Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
+@deftypefn {GIMPLE function} bool gimple_call_tail_p (gcall *s)
+Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
@end deftypefn
@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
-@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
+@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gcall *stmt, @
+bitmap args_to_skip)
Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
in the positions marked by the set @code{ARGS_TO_SKIP}.
@end deftypefn
@subsection @code{GIMPLE_CATCH}
@cindex @code{GIMPLE_CATCH}
-@deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
+@deftypefn {GIMPLE function} gcatch *gimple_build_catch (tree types, @
+gimple_seq handler)
Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this
catch handles. @code{HANDLER} is a sequence of statements with the code
for the handler.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
-Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
+@deftypefn {GIMPLE function} tree gimple_catch_types (const gcatch *g)
+Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_catch_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gcatch *g)
Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gcatch *g)
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
-@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}.
+@deftypefn {GIMPLE function} void gimple_catch_set_types (gcatch *g, tree t)
+Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
-Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
+@deftypefn {GIMPLE function} void gimple_catch_set_handler (gcatch *g, @
+gimple_seq handler)
+Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
@subsection @code{GIMPLE_COND}
@cindex @code{GIMPLE_COND}
-@deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gcond *gimple_build_cond ( @
+enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares
@code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gcond *gimple_build_cond_from_tree (tree cond, @
+tree t_label, tree f_label)
Build a @code{GIMPLE_COND} statement from the conditional expression
tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
@end deftypefn
-@deftypefn {GIMPLE function} enum tree_code gimple_cond_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
Return the code of the predicate computed by conditional
-statement @code{G}.
+statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
+@deftypefn {GIMPLE function} void gimple_cond_set_code (gcond *g, @
+enum tree_code code)
Set @code{CODE} to be the predicate code for the conditional statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
Return the @code{LHS} of the predicate computed by conditional statement
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gcond *g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
-conditional statement @code{G}.
+conditional statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
Return the @code{RHS} operand of the predicate computed by conditional
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gcond *g, tree rhs)
Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
-conditional statement @code{G}.
+conditional statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_true_label (const gcond *g)
Return the label used by conditional statement @code{G} when its
-predicate evaluates to true.
+predicate evaluates to true.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gcond *g, tree label)
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
-@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gcond *g, tree label)
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
-@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_false_label (const gcond *g)
Return the label used by conditional statement @code{G} when its
-predicate evaluates to false.
+predicate evaluates to false.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_make_false (gcond *g)
+Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_cond_make_true (gcond *g)
+Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
+@end deftypefn
+
+@node @code{GIMPLE_DEBUG}
+@subsection @code{GIMPLE_DEBUG}
+@cindex @code{GIMPLE_DEBUG}
+@cindex @code{GIMPLE_DEBUG_BIND}
+@cindex @code{GIMPLE_DEBUG_BEGIN_STMT}
+@cindex @code{GIMPLE_DEBUG_INLINE_ENTRY}
+
+@deftypefn {GIMPLE function} gdebug *gimple_build_debug_bind (tree var, @
+tree value, gimple stmt)
+Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND}
+@code{subcode}. The effect of this statement is to tell debug
+information generation machinery that the value of user variable
+@code{var} is given by @code{value} at that point, and to remain with
+that value until @code{var} runs out of scope, a
+dynamically-subsequent debug bind statement overrides the binding, or
+conflicting values reach a control flow merge point. Even if
+components of the @code{value} expression change afterwards, the
+variable is supposed to retain the same value, though not necessarily
+the same location.
+
+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
+requirements for gimple registers, but it may also be a tree for a
+scalarized component of a user variable (@code{ARRAY_REF},
+@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
+recommended that it be in a suitable form for a gimple assignment
+@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
+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
+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
+refer to the value bound to a user variable within a @code{value}
+expression.
+
+If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
+generation machinery is informed that the variable @code{var} is
+unbound, i.e., that its value is indeterminate, which sometimes means
+it is really unavailable, and other times that the compiler could not
+keep track of it.
+
+Block and location information for the newly-created stmt are
+taken from @code{stmt}, if given.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
+Return the user variable @var{var} that is bound at @code{stmt}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
+Return the value expression that is bound to a user variable at
+@code{stmt}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
-Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
+@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
+variable at @code{stmt}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
-Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
+@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
+Modify the user variable bound at @code{stmt} to @var{var}.
+@end deftypefn
+
+@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
+@var{value}.
+@end deftypefn
+
+@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
+Modify the value bound to the user variable bound at @code{stmt} so
+that the variable becomes unbound.
+@end deftypefn
+
+@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,
+and @code{FALSE} if it unbinds the variable.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gimple_build_debug_begin_stmt (tree block, location_t location)
+Build a @code{GIMPLE_DEBUG} statement with
+@code{GIMPLE_DEBUG_BEGIN_STMT} @code{subcode}. The effect of this
+statement is to tell debug information generation machinery that the
+user statement at the given @code{location} and @code{block} starts at
+the point at which the statement is inserted. The intent is that side
+effects (e.g.@: variable bindings) of all prior user statements are
+observable, and that none of the side effects of subsequent user
+statements are.
+@end deftypefn
+
+@deftypefn {GIMPLE function} gimple gimple_build_debug_inline_entry (tree block, location_t location)
+Build a @code{GIMPLE_DEBUG} statement with
+@code{GIMPLE_DEBUG_INLINE_ENTRY} @code{subcode}. The effect of this
+statement is to tell debug information generation machinery that a
+function call at @code{location} underwent inline substitution, that
+@code{block} is the enclosing lexical block created for the
+substitution, and that at the point of the program in which the stmt is
+inserted, all parameters for the inlined function are bound to the
+respective arguments, and none of the side effects of its stmts are
+observable.
@end deftypefn
@node @code{GIMPLE_EH_FILTER}
@subsection @code{GIMPLE_EH_FILTER}
@cindex @code{GIMPLE_EH_FILTER}
-@deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
+@deftypefn {GIMPLE function} geh_filter *gimple_build_eh_filter (tree types, @
+gimple_seq failure)
Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's
types. @code{FAILURE} is a sequence with the filter's failure action.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
-Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
+Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_eh_filter_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
-statement fails.
+statement fails.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
-Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (geh_filter *g, @
+tree types)
+Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (geh_filter *g, @
+gimple_seq failure)
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
-@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
-Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
+@deftypefn {GIMPLE function} tree gimple_eh_must_not_throw_fndecl ( @
+geh_mnt *eh_mnt_stmt)
+Get the function decl to be called by the MUST_NOT_THROW region.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
-Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
+@deftypefn {GIMPLE function} void gimple_eh_must_not_throw_set_fndecl ( @
+geh_mnt *eh_mnt_stmt, tree decl)
+Set the function decl to be called by GS to DECL.
@end deftypefn
@subsection @code{GIMPLE_LABEL}
@cindex @code{GIMPLE_LABEL}
-@deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
+@deftypefn {GIMPLE function} glabel *gimple_build_label (tree label)
Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
label, @code{LABEL}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
-Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
+@deftypefn {GIMPLE function} tree gimple_label_label (const glabel *g)
+Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_label_set_label (glabel *g, tree label)
Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
+@node @code{GIMPLE_GOTO}
+@subsection @code{GIMPLE_GOTO}
+@cindex @code{GIMPLE_GOTO}
-@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
+@deftypefn {GIMPLE function} ggoto *gimple_build_goto (tree dest)
Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
-Return the destination of the unconditional jump @code{G}.
+Return the destination of the unconditional jump @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
+@deftypefn {GIMPLE function} void gimple_goto_set_dest (ggoto *g, tree dest)
Set @code{DEST} to be the destination of the unconditional jump @code{G}.
@end deftypefn
@end deftypefn
@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
@node @code{GIMPLE_OMP_ATOMIC_LOAD}
@subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
@cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gomp_atomic_load *gimple_build_omp_atomic_load ( @
+tree lhs, tree rhs)
Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand
side of the assignment. @code{RHS} is the right-hand side of the
assignment.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
-Set the @code{LHS} of an atomic load.
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs ( @
+gomp_atomic_load *g, tree lhs)
+Set the @code{LHS} of an atomic load.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
-Get the @code{LHS} of an atomic load.
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs ( @
+const gomp_atomic_load *g)
+Get the @code{LHS} of an atomic load.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
-Set the @code{RHS} of an atomic set.
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs ( @
+gomp_atomic_load *g, tree rhs)
+Set the @code{RHS} of an atomic set.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
-Get the @code{RHS} of an atomic set.
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs ( @
+const gomp_atomic_load *g)
+Get the @code{RHS} of an atomic set.
@end deftypefn
@subsection @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} gomp_atomic_store *gimple_build_omp_atomic_store ( @
+tree val)
Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
stored.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
-Set the value being stored in an atomic store.
+@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val ( @
+gomp_atomic_store *g, tree val)
+Set the value being stored in an atomic store.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
-Return the value being stored in an atomic store.
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val ( @
+const gomp_atomic_store *g)
+Return the value being stored in an atomic store.
@end deftypefn
@node @code{GIMPLE_OMP_CONTINUE}
@subsection @code{GIMPLE_OMP_CONTINUE}
@cindex @code{GIMPLE_OMP_CONTINUE}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
+@deftypefn {GIMPLE function} gomp_continue *gimple_build_omp_continue ( @
+tree control_def, tree control_use)
Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the
definition of the control variable. @code{CONTROL_USE} is the use of
the control variable.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def ( @
+const gomp_continue *s)
Return the definition of the control variable on a
@code{GIMPLE_OMP_CONTINUE} in @code{S}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
+
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr ( @
+gomp_continue *s)
Same as above, but return the pointer.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
+
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def ( @
+gomp_continue *s)
Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
statement in @code{S}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
+
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use ( @
+const gomp_continue *s)
Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
in @code{S}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
+
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr ( @
+gomp_continue *s)
Same as above, but return the pointer.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
+
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use ( @
+gomp_continue *s)
Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
in @code{S}.
@end deftypefn
@subsection @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} gomp_critical *gimple_build_omp_critical ( @
+gimple_seq body, tree name)
Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
statements for which only one thread can execute. @code{NAME} is an
optional identifier for this critical block.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
-Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
+@deftypefn {GIMPLE function} tree gimple_omp_critical_name ( @
+const gomp_critical *g)
+Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_omp_critical_name_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr ( @
+gomp_critical *g)
Return a pointer to the name associated with @code{OMP} critical
-statement @code{G}.
+statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
-Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
+@deftypefn {GIMPLE function} void gimple_omp_critical_set_name ( @
+gomp_critical *g, tree name)
+Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
@end deftypefn
@node @code{GIMPLE_OMP_FOR}
@subsection @code{GIMPLE_OMP_FOR}
@cindex @code{GIMPLE_OMP_FOR}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
+@deftypefn {GIMPLE function} gomp_for *gimple_build_omp_for (gimple_seq body, @
tree clauses, tree index, tree initial, tree final, tree incr, @
gimple_seq pre_body, enum tree_code omp_for_cond)
Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
-inside the for loop. @code{CLAUSES}, are any of the @code{OMP} loop
-construct's clauses: private, firstprivate, lastprivate,
-reductions, ordered, schedule, and nowait. @code{PRE_BODY} is the
+inside the for loop. @code{CLAUSES}, are any of the loop
+construct's clauses. @code{PRE_BODY} is the
sequence of statements that are loop invariant. @code{INDEX} is the
index variable. @code{INITIAL} is the initial value of @code{INDEX}. @code{FINAL} is
final value of @code{INDEX}. OMP_FOR_COND is the predicate used to
@end deftypefn
@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
-@deftypefn {GIMPLE function} tree *gimple_omp_for_clauses_ptr (gimple g)
-Return a pointer to the @code{OMP_FOR} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
+Return a pointer to the @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
+Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
-Return the index variable for @code{OMP_FOR} @code{G}.
+Return the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_omp_for_index_ptr (gimple g)
-Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
+Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
-Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
+Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
-Return the initial value for @code{OMP_FOR} @code{G}.
+Return the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_omp_for_initial_ptr (gimple g)
-Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
+Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
@end deftypefn
@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
-@deftypefn {GIMPLE function} tree *gimple_omp_for_final_ptr (gimple g)
-turn a pointer to the final value for @code{OMP_FOR} @code{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}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
-Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
+Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
-Return the increment value for @code{OMP_FOR} @code{G}.
+Return the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_omp_for_incr_ptr (gimple g)
-Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
+Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
-Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
+Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
Return the sequence of statements to execute before the @code{OMP_FOR}
-statement @code{G} starts.
+statement @code{G} starts.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
Set @code{PRE_BODY} to be the sequence of statements to execute before
the @code{OMP_FOR} statement @code{G} starts.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
-Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
+Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} enum tree_code gimple_omp_for_cond (gimple g)
-Return the condition code associated with @code{OMP_FOR} @code{G}.
+@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
+Return the condition code associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
Build a @code{GIMPLE_OMP_ORDERED} statement.
-@end deftypefn
@code{BODY} is the sequence of statements inside a loop that will
executed in sequence.
-
+@end deftypefn
@node @code{GIMPLE_OMP_PARALLEL}
@subsection @code{GIMPLE_OMP_PARALLEL}
@cindex @code{GIMPLE_OMP_PARALLEL}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg)
+@deftypefn {GIMPLE function} gomp_parallel *gimple_build_omp_parallel (@
+gimple_seq body, tree clauses, tree child_fn, tree data_arg)
Build a @code{GIMPLE_OMP_PARALLEL} statement.
-@end deftypefn
@code{BODY} is sequence of statements which are executed in parallel.
@code{CLAUSES}, are the @code{OMP} parallel construct's clauses. @code{CHILD_FN} is
the function created for the parallel threads to execute.
@code{DATA_ARG} are the shared data argument(s).
+@end deftypefn
@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
Return true if @code{OMP} parallel statement @code{G} has the
@code{GF_OMP_PARALLEL_COMBINED} flag set.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
@code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
-Return the body for the @code{OMP} statement @code{G}.
+Return the body for the @code{OMP} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
-Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
+Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
-Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
+Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_omp_parallel_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr ( @
+gomp_parallel *g)
+Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses ( @
+gomp_parallel *g, tree clauses)
Set @code{CLAUSES} to be the list of clauses associated with
-@code{OMP_PARALLEL} @code{G}.
+@code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn ( @
+const gomp_parallel *g)
Return the child function used to hold the body of @code{OMP_PARALLEL}
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_omp_parallel_child_fn_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr ( @
+gomp_parallel *g)
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
-@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}.
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn ( @
+gomp_parallel *g, tree child_fn)
+Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg ( @
+const gomp_parallel *g)
Return the artificial argument used to send variables and values
-from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
-@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_omp_parallel_data_arg_ptr (gimple g)
-Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
+from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
-Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr ( @
+gomp_parallel *g)
+Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt)
-Returns true when the gimple statement @code{STMT} is any of the OpenMP
-types.
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg ( @
+gomp_parallel *g, tree data_arg)
+Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
Return true if @code{OMP} return statement @code{G} has the
@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
-@end deftypefn
@code{BODY} is the sequence of statements in the section.
+@end deftypefn
@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
Return true if @code{OMP} section statement @code{G} has the
@code{GF_OMP_SECTION_LAST} flag set.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
@end deftypefn
@subsection @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} gomp_sections *gimple_build_omp_sections ( @
+gimple_seq body, tree clauses)
Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
section statements. @code{CLAUSES} are any of the @code{OMP} sections
construct's clauses: private, firstprivate, lastprivate,
Return the control variable associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-
-@deftypefn {GIMPLE function} tree *gimple_omp_sections_control_ptr (gimple g)
+
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
Return a pointer to the clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
Set @code{CONTROL} to be the set of clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
-Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
+Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_omp_sections_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
+Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
-@code{G}.
+@code{G}.
@end deftypefn
@subsection @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} gomp_single *gimple_build_omp_single ( @
+gimple_seq body, tree clauses)
Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
statements that will be executed once. @code{CLAUSES} are any of the
@code{OMP} single construct's clauses: private, firstprivate,
@end deftypefn
@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
-@deftypefn {GIMPLE function} tree *gimple_omp_single_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{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}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
+@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses ( @
+gomp_single *g, tree clauses)
+Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@subsection @code{GIMPLE_PHI}
@cindex @code{GIMPLE_PHI}
-@deftypefn {GIMPLE function} gimple make_phi_node (tree var, int len)
-Build a @code{PHI} node with len argument slots for variable var.
-@end deftypefn
-
@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
-Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
+Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
be exactly the number of incoming edges for the basic block
-holding @code{G}.
+holding @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
-Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
+Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree *gimple_phi_result_ptr (gimple g)
-Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
+@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
+Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
-Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
+@deftypefn {GIMPLE function} void gimple_phi_set_result (gphi *g, tree result)
+Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} struct phi_arg_d *gimple_phi_arg (gimple g, index)
+@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
-@code{GIMPLE_PHI} @code{G}.
+@code{GIMPLE_PHI} @code{G}.
@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 (gphi *g, index, @
+struct phi_arg_d * phiarg)
Set @code{PHIARG} to be the argument corresponding to incoming edge
-@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
+@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@node @code{GIMPLE_RESX}
@subsection @code{GIMPLE_RESX}
@cindex @code{GIMPLE_RESX}
-@deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
+@deftypefn {GIMPLE function} gresx *gimple_build_resx (int region)
Build a @code{GIMPLE_RESX} statement which is a statement. This
statement is a placeholder for _Unwind_Resume before we know if a
function call or a branch is needed. @code{REGION} is the exception
region from which control is flowing.
@end deftypefn
-@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
-Return the region number for @code{GIMPLE_RESX} @code{G}.
+@deftypefn {GIMPLE function} int gimple_resx_region (const gresx *g)
+Return the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
-Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
+@deftypefn {GIMPLE function} void gimple_resx_set_region (gresx *g, int region)
+Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
@node @code{GIMPLE_RETURN}
@subsection @code{GIMPLE_RETURN}
@cindex @code{GIMPLE_RETURN}
-@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
+@deftypefn {GIMPLE function} greturn *gimple_build_return (tree retval)
Build a @code{GIMPLE_RETURN} statement whose return value is retval.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
-Return the return value for @code{GIMPLE_RETURN} @code{G}.
+@deftypefn {GIMPLE function} tree gimple_return_retval (const greturn *g)
+Return the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
-Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
+@deftypefn {GIMPLE function} void gimple_return_set_retval (greturn *g, @
+tree retval)
+Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
@node @code{GIMPLE_SWITCH}
@subsection @code{GIMPLE_SWITCH}
@cindex @code{GIMPLE_SWITCH}
-@deftypefn {GIMPLE function} gimple gimple_build_switch ( nlabels, tree index, tree default_label, ...)
-Build a @code{GIMPLE_SWITCH} statement. @code{NLABELS} are the number of
-labels excluding the default label. The default label is passed
-in @code{DEFAULT_LABEL}. The rest of the arguments are trees
-representing the labels. Each label is a tree of code
-@code{CASE_LABEL_EXPR}.
-@end deftypefn
-
-@deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree default_label, @code{VEC}(tree,heap) *args)
-This function is an alternate way of building @code{GIMPLE_SWITCH}
-statements. @code{INDEX} and @code{DEFAULT_LABEL} are as in
-gimple_build_switch. @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees
-that contain the labels.
+@deftypefn {GIMPLE function} gswitch *gimple_build_switch (tree index, @
+tree default_label, @code{vec}<tree> *args)
+Build a @code{GIMPLE_SWITCH} statement. @code{INDEX} is the index variable
+to switch on, and @code{DEFAULT_LABEL} represents the default label.
+@code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
+non-default case labels. Each label is a tree of code @code{CASE_LABEL_EXPR}.
@end deftypefn
-@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels ( @
+const gswitch *g)
Return the number of labels associated with the switch statement
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, unsigned nlabels)
+@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gswitch *g, @
+unsigned nlabels)
Set @code{NLABELS} to be the number of labels for the switch statement
-@code{G}.
+@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
-Return the index variable used by the switch statement @code{G}.
+@deftypefn {GIMPLE function} tree gimple_switch_index (const gswitch *g)
+Return the index variable used by the switch statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
-Set @code{INDEX} to be the index variable for switch statement @code{G}.
+@deftypefn {GIMPLE function} void gimple_switch_set_index (gswitch *g, @
+tree index)
+Set @code{INDEX} to be the index variable for switch statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_switch_label (const gswitch *g, @
+unsigned index)
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
-@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned index, tree label)
+@deftypefn {GIMPLE function} void gimple_switch_set_label (gswitch *g, @
+unsigned index, tree label)
Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
-label.
+label.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
-Return the default label for a switch statement.
+@deftypefn {GIMPLE function} tree gimple_switch_default_label ( @
+const gswitch *g)
+Return the default label for a switch statement.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, tree label)
-Set the default label for a switch statement.
+@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gswitch *g, @
+tree label)
+Set the default label for a switch statement.
@end deftypefn
@subsection @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} gtry *gimple_build_try (gimple_seq eval, @
+gimple_seq cleanup, unsigned int kind)
Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the
expression to evaluate. @code{CLEANUP} is a sequence of statements to
run at clean-up time. @code{KIND} is the enumeration value
construct.
@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
-either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
+either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
-Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
+Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
Return the sequence of statements used as the body for @code{GIMPLE_TRY}
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
Return the sequence of statements used as the cleanup body for
-@code{GIMPLE_TRY} @code{G}.
+@code{GIMPLE_TRY} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
-Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
+@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
+bool catch_is_cleanup)
+Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
+@deftypefn {GIMPLE function} void gimple_try_set_eval (gtry *g, gimple_seq eval)
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
-@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
+@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gtry *g, @
+gimple_seq cleanup)
Set @code{CLEANUP} to be the sequence of statements to use as the
-cleanup body for @code{GIMPLE_TRY} @code{G}.
+cleanup body for @code{GIMPLE_TRY} @code{G}.
@end deftypefn
@node @code{GIMPLE_WITH_CLEANUP_EXPR}
@end deftypefn
@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
@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
@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
@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
-@node GIMPLE sequences
-@section GIMPLE sequences
-@cindex GIMPLE sequences
+@node GIMPLE sequences
+@section GIMPLE sequences
+@cindex GIMPLE sequences
GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
used in @code{GENERIC}. They are used to chain statements together, and
Determine whether @code{SEQ} contains exactly one statement.
@end deftypefn
-@node Sequence iterators
-@section Sequence iterators
-@cindex Sequence iterators
+@node Sequence iterators
+@section Sequence iterators
+@cindex Sequence iterators
Sequence iterators are convenience constructs for iterating
through statements in a sequence. Given a sequence @code{SEQ}, here is
non-label statement in block @code{BB}.
@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.
@end deftypefn
Updates iterator @code{I} according to @code{MODE}.
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, @
+gimple_seq seq, enum gsi_iterator_update mode)
Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
@code{MODE} is as in @code{gsi_insert_after}.
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
+gimple g, enum gsi_iterator_update mode)
Links statement @code{G} after the statement pointed-to by iterator @code{I}.
@code{MODE} is as in @code{gsi_insert_after}.
@end deftypefn
Return this new sequence.
@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}
is true, the exception handling information of the original
statement is moved to the new statement.
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
+gimple stmt, enum gsi_iterator_update mode)
Insert statement @code{STMT} before the statement pointed-to by iterator
@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
specifies how to update iterator @code{I} after insertion (see enum
@code{gsi_iterator_update}).
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, @
+gimple_seq seq, enum gsi_iterator_update mode)
Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
+gimple stmt, enum gsi_iterator_update mode)
Insert statement @code{STMT} after the statement pointed-to by iterator
@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
specifies how to update iterator @code{I} after insertion (see enum
@code{gsi_iterator_update}).
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, @
+gimple_seq seq, enum gsi_iterator_update mode)
Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
@end deftypefn
Finds iterator for @code{STMT}.
@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
at @code{TO}.
@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
at @code{TO}.
@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}.
@end deftypefn
The first step in adding a new GIMPLE statement code, is
modifying the file @code{gimple.def}, which contains all the GIMPLE
-codes. Then you must add a corresponding structure, and an entry
-in @code{union gimple_statement_d}, both of which are located in
-@code{gimple.h}. This in turn, will require you to add a corresponding
-@code{GTY} tag in @code{gsstruct.def}, and code to handle this tag in
-@code{gss_for_code} which is located in @code{gimple.c}.
+codes. Then you must add a corresponding gimple subclass
+located in @code{gimple.h}. This in turn, will require you to add a
+corresponding @code{GTY} tag in @code{gsstruct.def}, and code to handle
+this tag in @code{gss_for_code} which is located in @code{gimple.cc}.
In order for the garbage collector to know the size of the
structure you created in @code{gimple.h}, you need to add a case to
handle your new GIMPLE statement in @code{gimple_size} which is located
-in @code{gimple.c}.
+in @code{gimple.cc}.
You will probably want to create a function to build the new
-gimple statement in @code{gimple.c}. The function should be called
-@code{gimple_build_<@code{NEW_TUPLE_NAME}>}, and should return the new tuple
-of type gimple.
+gimple statement in @code{gimple.cc}. The function should be called
+@code{gimple_build_@var{new-tuple-name}}, and should return the new tuple
+as a pointer to the appropriate gimple subclass.
If your new statement requires accessors for any members or
operands it may have, put simple inline accessors in
-@code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
+@code{gimple.h} and any non-trivial accessors in @code{gimple.cc} with a
corresponding prototype in @code{gimple.h}.
+You should add the new statement subclass to the class hierarchy diagram
+in @code{gimple.texi}.
+
@node Statement and operand traversals
@section Statement and operand traversals
@cindex Statement and operand traversals
-
+
There are two functions available for walking statements and
sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
accordingly, and a third function for walking the operands in a
statement: @code{walk_gimple_op}.
-@deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
+@deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, @
+ walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
This function is used to walk the current statement in @code{GSI},
optionally using traversal state stored in @code{WI}. If @code{WI} is @code{NULL}, no
state is kept during the traversal.
@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
operand is walked via @code{walk_tree} with optional state information
in @code{WI}.
each operand @code{OP}, @code{walk_tree} is called as:
@smallexample
- walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{WI}- @code{PSET})
+walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{PSET})
@end smallexample
If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
@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}
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