1 GIMPLE

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

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

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

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

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

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

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

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


Next: , Up: GIMPLE

1.1 Tuple representation

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

1.1.1 gimple_statement_base (gsbase)

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

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

1.1.2 gimple_statement_with_ops

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

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

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

1.1.3 gimple_statement_with_memory_ops

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

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

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

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


Next: , Previous: Tuple representation, Up: GIMPLE

1.2 GIMPLE instruction set

The following table briefly describes the GIMPLE instruction set.

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


Next: , Previous: GIMPLE instruction set, Up: GIMPLE

1.3 Exception Handling

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

  1. A sequence of statements to execute. When an exception occurs, these statements are executed, and then the exception is rethrown.
  2. A sequence of GIMPLE_CATCH statements. Each GIMPLE_CATCH has a list of applicable exception types and handler code. If the thrown exception matches one of the caught types, the associated handler code is executed. If the handler code falls off the bottom, execution continues after the original GIMPLE_TRY_CATCH.
  3. An GIMPLE_EH_FILTER statement. This has a list of permitted exception types, and code to handle a match failure. If the thrown exception does not match one of the allowed types, the associated match failure code is executed. If the thrown exception does match, it continues unwinding the stack looking for the next handler.

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

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


Next: , Previous: GIMPLE Exception Handling, Up: GIMPLE

1.4 Temporaries

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

We can only use expression temporaries when we know that it will not be reevaluated before its value is used, and that it will not be otherwise modified1. Other temporaries can be allocated using get_initialized_tmp_var or create_tmp_var.

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

       T1 = b + 5;
       a = T1;

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


Next: , Previous: Temporaries, Up: GIMPLE

1.5 Operands

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

       a = b + c + d

becomes

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

The same rule holds for arguments to a GIMPLE_CALL.

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


Next: , Up: Operands

1.5.1 Compound Expressions

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


Next: , Previous: Compound Expressions, Up: Operands

1.5.2 Compound Lvalues

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

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

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


Next: , Previous: Compound Lvalues, Up: Operands

1.5.3 Conditional Expressions

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

       a = b ? c : d;

becomes

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

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

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


Previous: Conditional Expressions, Up: Operands

1.5.4 Logical Operators

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

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

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

1.5.5 Manipulating operands

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

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

     a = b + c

its tree representation is:

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

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

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

1.5.6 Operand vector allocation

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

— GIMPLE function: unsigned gimple_num_ops (gimple g)

Returns the number of operands in statement G.

— GIMPLE function: tree gimple_op (gimple g, unsigned i)

Returns operand I from statement G.

— GIMPLE function: tree *gimple_ops (gimple g)

Returns a pointer into the operand vector for statement G. This is computed using an internal table called gimple_ops_offset_[]. This table is indexed by the gimple code of G.

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

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

1.5.7 Operand validation

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

— GIMPLE function: is_gimple_operand (tree t)

This is the most permissive of the predicates. It essentially checks whether t has a gimple_rhs_class of GIMPLE_SINGLE_RHS.

— GIMPLE function: is_gimple_val (tree t)

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

— GIMPLE function: is_gimple_addressable (tree t)

Returns true if t is a symbol or memory reference whose address can be taken.

— GIMPLE function: is_gimple_asm_val (tree t)

Similar to is_gimple_val but it also accepts hard registers.

— GIMPLE function: is_gimple_call_addr (tree t)

Return true if t is a valid expression to use as the function called by a GIMPLE_CALL.

— GIMPLE function: is_gimple_constant (tree t)

Return true if t is a valid gimple constant.

— GIMPLE function: is_gimple_min_invariant (tree t)

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

— GIMPLE function: is_gimple_min_invariant_address (tree t)

Return true if t is an ADDR_EXPR that does not change once the program is running.

1.5.8 Statement validation

— GIMPLE function: is_gimple_assign (gimple g)

Return true if the code of g is GIMPLE_ASSIGN.

— GIMPLE function: is_gimple_call (gimple g)

Return true if the code of g is GIMPLE_CALL

— GIMPLE function: gimple_assign_cast_p (gimple g)

Return true if g is a GIMPLE_ASSIGN that performs a type cast operation


Next: , Previous: Operands, Up: GIMPLE

1.6 Manipulating GIMPLE statements

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

1.6.1 Common accessors

The following are common accessors for gimple statements.

— GIMPLE function: enum gimple_code gimple_code (gimple g)

Return the code for statement G.

— GIMPLE function: basic_block gimple_bb (gimple g)

Return the basic block to which statement G belongs to.

— GIMPLE function: tree gimple_block (gimple g)

Return the lexical scope block holding statement G.

— GIMPLE function: tree gimple_expr_type (gimple stmt)

Return the type of the main expression computed by STMT. Return void_type_node if STMT computes nothing. This will only return something meaningful for GIMPLE_ASSIGN, GIMPLE_COND and GIMPLE_CALL. For all other tuple codes, it will return void_type_node.

— GIMPLE function: enum tree_code gimple_expr_code (gimple stmt)

Return the tree code for the expression computed by STMT. This is only meaningful for GIMPLE_CALL, GIMPLE_ASSIGN and GIMPLE_COND. If STMT is GIMPLE_CALL, it will return CALL_EXPR. For GIMPLE_COND, it returns the code of the comparison predicate. For GIMPLE_ASSIGN it returns the code of the operation performed by the RHS of the assignment.

— GIMPLE function: void gimple_set_block (gimple g, tree block)

Set the lexical scope block of G to BLOCK.

— GIMPLE function: location_t gimple_locus (gimple g)

Return locus information for statement G.

— GIMPLE function: void gimple_set_locus (gimple g, location_t locus)

Set locus information for statement G.

— GIMPLE function: bool gimple_locus_empty_p (gimple g)

Return true if G does not have locus information.

— GIMPLE function: bool gimple_no_warning_p (gimple stmt)

Return true if no warnings should be emitted for statement STMT.

— GIMPLE function: void gimple_set_visited (gimple stmt, bool visited_p)

Set the visited status on statement STMT to VISITED_P.

— GIMPLE function: bool gimple_visited_p (gimple stmt)

Return the visited status on statement STMT.

— GIMPLE function: void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)

Set pass local flag PLF on statement STMT to VAL_P.

— GIMPLE function: unsigned int gimple_plf (gimple stmt, enum plf_mask plf)

Return the value of pass local flag PLF on statement STMT.

— GIMPLE function: bool gimple_has_ops (gimple g)

Return true if statement G has register or memory operands.

— GIMPLE function: bool gimple_has_mem_ops (gimple g)

Return true if statement G has memory operands.

— GIMPLE function: unsigned gimple_num_ops (gimple g)

Return the number of operands for statement G.

— GIMPLE function: tree *gimple_ops (gimple g)

Return the array of operands for statement G.

— GIMPLE function: tree gimple_op (gimple g, unsigned i)

Return operand I for statement G.

— GIMPLE function: tree *gimple_op_ptr (gimple g, unsigned i)

Return a pointer to operand I for statement G.

— GIMPLE function: void gimple_set_op (gimple g, unsigned i, tree op)

Set operand I of statement G to OP.

— GIMPLE function: bitmap gimple_addresses_taken (gimple stmt)

Return the set of symbols that have had their address taken by STMT.

— GIMPLE function: struct def_optype_d *gimple_def_ops (gimple g)

Return the set of DEF operands for statement G.

— GIMPLE function: void gimple_set_def_ops (gimple g, struct def_optype_d *def)

Set DEF to be the set of DEF operands for statement G.

— GIMPLE function: struct use_optype_d *gimple_use_ops (gimple g)

Return the set of USE operands for statement G.

— GIMPLE function: void gimple_set_use_ops (gimple g, struct use_optype_d *use)

Set USE to be the set of USE operands for statement G.

— GIMPLE function: struct voptype_d *gimple_vuse_ops (gimple g)

Return the set of VUSE operands for statement G.

— GIMPLE function: void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)

Set OPS to be the set of VUSE operands for statement G.

— GIMPLE function: struct voptype_d *gimple_vdef_ops (gimple g)

Return the set of VDEF operands for statement G.

— GIMPLE function: void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)

Set OPS to be the set of VDEF operands for statement G.

— GIMPLE function: bitmap gimple_loaded_syms (gimple g)

Return the set of symbols loaded by statement G. Each element of the set is the DECL_UID of the corresponding symbol.

— GIMPLE function: bitmap gimple_stored_syms (gimple g)

Return the set of symbols stored by statement G. Each element of the set is the DECL_UID of the corresponding symbol.

— GIMPLE function: bool gimple_modified_p (gimple g)

Return true if statement G has operands and the modified field has been set.

— GIMPLE function: bool gimple_has_volatile_ops (gimple stmt)

Return true if statement STMT contains volatile operands.

— GIMPLE function: void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)

Return true if statement STMT contains volatile operands.

— GIMPLE function: void update_stmt (gimple s)

Mark statement S as modified, and update it.

— GIMPLE function: void update_stmt_if_modified (gimple s)

Update statement S if it has been marked modified.

— GIMPLE function: gimple gimple_copy (gimple stmt)

Return a deep copy of statement STMT.


Next: , Previous: Manipulating GIMPLE statements, Up: GIMPLE

1.7 Tuple specific accessors


Next: , Up: Tuple specific accessors

1.7.1 GIMPLE_ASM

— GIMPLE function: gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)

Build a GIMPLE_ASM statement. This statement is used for building in-line assembly constructs. STRING is the assembly code. NINPUT is the number of register inputs. NOUTPUT is the number of register outputs. NCLOBBERS is the number of clobbered registers. The rest of the arguments trees for each input, output, and clobbered registers.

— GIMPLE function: gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)

Identical to gimple_build_asm, but the arguments are passed in VECs.

— GIMPLE function: gimple_asm_ninputs (gimple g)

Return the number of input operands for GIMPLE_ASM G.

— GIMPLE function: gimple_asm_noutputs (gimple g)

Return the number of output operands for GIMPLE_ASM G.

— GIMPLE function: gimple_asm_nclobbers (gimple g)

Return the number of clobber operands for GIMPLE_ASM G.

— GIMPLE function: tree gimple_asm_input_op (gimple g, unsigned index)

Return input operand INDEX of GIMPLE_ASM G.

— GIMPLE function: void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)

Set IN_OP to be input operand INDEX in GIMPLE_ASM G.

— GIMPLE function: tree gimple_asm_output_op (gimple g, unsigned index)

Return output operand INDEX of GIMPLE_ASM G.

— GIMPLE function: void gimple_asm_set_output_op (gimple g, unsigned index, tree out_op)

Set OUT_OP to be output operand INDEX in GIMPLE_ASM G.

— GIMPLE function: tree gimple_asm_clobber_op (gimple g, unsigned index)

Return clobber operand INDEX of GIMPLE_ASM G.

— GIMPLE function: void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)

Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM G.

— GIMPLE function: const char *gimple_asm_string (gimple g)

Return the string representing the assembly instruction in GIMPLE_ASM G.

— GIMPLE function: bool gimple_asm_volatile_p (gimple g)

Return true if G is an asm statement marked volatile.

— GIMPLE function: void gimple_asm_set_volatile (gimple g)

Mark asm statement G as volatile.

— GIMPLE function: void gimple_asm_clear_volatile (gimple g)

Remove volatile marker from asm statement G.


Next: , Previous: <code>GIMPLE_ASM</code>, Up: Tuple specific accessors

1.7.2 GIMPLE_ASSIGN

— GIMPLE function: gimple gimple_build_assign (tree lhs, tree rhs)

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

— GIMPLE function: gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)

Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.

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

This function returns the newly created GIMPLE_ASSIGN tuple.

— GIMPLE function: gimple gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1, tree op2)

This function is similar to gimple_build_assign, but is used to build a GIMPLE_ASSIGN statement when the operands of the right-hand side of the assignment are already split into different operands.

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

— GIMPLE function: enum tree_code gimple_assign_rhs_code (gimple g)

Return the code of the expression computed on the RHS of assignment statement G.

— GIMPLE function: enum gimple_rhs_class gimple_assign_rhs_class (gimple g)

Return the gimple rhs class of the code for the expression computed on the rhs of assignment statement G. This will never return GIMPLE_INVALID_RHS.

— GIMPLE function: tree gimple_assign_lhs (gimple g)

Return the LHS of assignment statement G.

— GIMPLE function: tree *gimple_assign_lhs_ptr (gimple g)

Return a pointer to the LHS of assignment statement G.

— GIMPLE function: tree gimple_assign_rhs1 (gimple g)

Return the first operand on the RHS of assignment statement G.

— GIMPLE function: tree *gimple_assign_rhs1_ptr (gimple g)

Return the address of the first operand on the RHS of assignment statement G.

— GIMPLE function: tree gimple_assign_rhs2 (gimple g)

Return the second operand on the RHS of assignment statement G.

— GIMPLE function: tree *gimple_assign_rhs2_ptr (gimple g)

Return the address of the second operand on the RHS of assignment statement G.

— GIMPLE function: void gimple_assign_set_lhs (gimple g, tree lhs)

Set LHS to be the LHS operand of assignment statement G.

— GIMPLE function: void gimple_assign_set_rhs1 (gimple g, tree rhs)

Set RHS to be the first operand on the RHS of assignment statement G.

— GIMPLE function: tree gimple_assign_rhs2 (gimple g)

Return the second operand on the RHS of assignment statement G.

— GIMPLE function: tree *gimple_assign_rhs2_ptr (gimple g)

Return a pointer to the second operand on the RHS of assignment statement G.

— GIMPLE function: void gimple_assign_set_rhs2 (gimple g, tree rhs)

Set RHS to be the second operand on the RHS of assignment statement G.

— GIMPLE function: bool gimple_assign_cast_p (gimple s)

Return true if S is an type-cast assignment.


Next: , Previous: <code>GIMPLE_ASSIGN</code>, Up: Tuple specific accessors

1.7.3 GIMPLE_BIND

— GIMPLE function: gimple gimple_build_bind (tree vars, gimple_seq body)

Build a GIMPLE_BIND statement with a list of variables in VARS and a body of statements in sequence BODY.

— GIMPLE function: tree gimple_bind_vars (gimple g)

Return the variables declared in the GIMPLE_BIND statement G.

— GIMPLE function: void gimple_bind_set_vars (gimple g, tree vars)

Set VARS to be the set of variables declared in the GIMPLE_BIND statement G.

— GIMPLE function: void gimple_bind_append_vars (gimple g, tree vars)

Append VARS to the set of variables declared in the GIMPLE_BIND statement G.

— GIMPLE function: gimple_seq gimple_bind_body (gimple g)

Return the GIMPLE sequence contained in the GIMPLE_BIND statement G.

— GIMPLE function: void gimple_bind_set_body (gimple g, gimple_seq seq)

Set SEQ to be sequence contained in the GIMPLE_BIND statement G.

— GIMPLE function: void gimple_bind_add_stmt (gimple gs, gimple stmt)

Append a statement to the end of a GIMPLE_BIND's body.

— GIMPLE function: void gimple_bind_add_seq (gimple gs, gimple_seq seq)

Append a sequence of statements to the end of a GIMPLE_BIND's body.

— GIMPLE function: tree gimple_bind_block (gimple g)

Return the TREE_BLOCK node associated with GIMPLE_BIND statement G. This is analogous to the BIND_EXPR_BLOCK field in trees.

— GIMPLE function: void gimple_bind_set_block (gimple g, tree block)

Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND statement G.


Next: , Previous: <code>GIMPLE_BIND</code>, Up: Tuple specific accessors

1.7.4 GIMPLE_CALL

— GIMPLE function: gimple gimple_build_call (tree fn, unsigned nargs, ...)

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

— GIMPLE function: gimple gimple_build_call_from_tree (tree call_expr)

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

— GIMPLE function: gimple gimple_build_call_vec (tree fn, VEC(tree, heap) *args)

Identical to gimple_build_call but the arguments are stored in a VEC().

— GIMPLE function: tree gimple_call_lhs (gimple g)

Return the LHS of call statement G.

— GIMPLE function: tree *gimple_call_lhs_ptr (gimple g)

Return a pointer to the LHS of call statement G.

— GIMPLE function: void gimple_call_set_lhs (gimple g, tree lhs)

Set LHS to be the LHS operand of call statement G.

— GIMPLE function: tree gimple_call_fn (gimple g)

Return the tree node representing the function called by call statement G.

— GIMPLE function: void gimple_call_set_fn (gimple g, tree fn)

Set FN to be the function called by call statement G. This has to be a gimple value specifying the address of the called function.

— GIMPLE function: tree gimple_call_fndecl (gimple g)

If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it. Otherwise return NULL. This function is analogous to get_callee_fndecl in GENERIC.

— GIMPLE function: tree gimple_call_set_fndecl (gimple g, tree fndecl)

Set the called function to FNDECL.

— GIMPLE function: tree gimple_call_return_type (gimple g)

Return the type returned by call statement G.

— GIMPLE function: tree gimple_call_chain (gimple g)

Return the static chain for call statement G.

— GIMPLE function: void gimple_call_set_chain (gimple g, tree chain)

Set CHAIN to be the static chain for call statement G.

— GIMPLE function: gimple_call_num_args (gimple g)

Return the number of arguments used by call statement G.

— GIMPLE function: tree gimple_call_arg (gimple g, unsigned index)

Return the argument at position INDEX for call statement G. The first argument is 0.

— GIMPLE function: tree *gimple_call_arg_ptr (gimple g, unsigned index)

Return a pointer to the argument at position INDEX for call statement G.

— GIMPLE function: void gimple_call_set_arg (gimple g, unsigned index, tree arg)

Set ARG to be the argument at position INDEX for call statement G.

— GIMPLE function: void gimple_call_set_tail (gimple s)

Mark call statement S as being a tail call (i.e., a call just before the exit of a function). These calls are candidate for tail call optimization.

— GIMPLE function: bool gimple_call_tail_p (gimple s)

Return true if GIMPLE_CALL S is marked as a tail call.

— GIMPLE function: void gimple_call_mark_uninlinable (gimple s)

Mark GIMPLE_CALL S as being uninlinable.

— GIMPLE function: bool gimple_call_cannot_inline_p (gimple s)

Return true if GIMPLE_CALL S cannot be inlined.

— GIMPLE function: bool gimple_call_noreturn_p (gimple s)

Return true if S is a noreturn call.

— GIMPLE function: gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)

Build a GIMPLE_CALL identical to STMT but skipping the arguments in the positions marked by the set ARGS_TO_SKIP.


Next: , Previous: <code>GIMPLE_CALL</code>, Up: Tuple specific accessors

1.7.5 GIMPLE_CATCH

— GIMPLE function: gimple gimple_build_catch (tree types, gimple_seq handler)

Build a GIMPLE_CATCH statement. TYPES are the tree types this catch handles. HANDLER is a sequence of statements with the code for the handler.

— GIMPLE function: tree gimple_catch_types (gimple g)

Return the types handled by GIMPLE_CATCH statement G.

— GIMPLE function: tree *gimple_catch_types_ptr (gimple g)

Return a pointer to the types handled by GIMPLE_CATCH statement G.

— GIMPLE function: gimple_seq gimple_catch_handler (gimple g)

Return the GIMPLE sequence representing the body of the handler of GIMPLE_CATCH statement G.

— GIMPLE function: void gimple_catch_set_types (gimple g, tree t)

Set T to be the set of types handled by GIMPLE_CATCH G.

— GIMPLE function: void gimple_catch_set_handler (gimple g, gimple_seq handler)

Set HANDLER to be the body of GIMPLE_CATCH G.


Next: , Previous: <code>GIMPLE_CATCH</code>, Up: Tuple specific accessors

1.7.6 GIMPLE_CHANGE_DYNAMIC_TYPE

— GIMPLE function: gimple gimple_build_cdt (tree type, tree ptr)

Build a GIMPLE_CHANGE_DYNAMIC_TYPE statement. TYPE is the new type for the location PTR.

— GIMPLE function: tree gimple_cdt_new_type (gimple g)

Return the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE statement G.

— GIMPLE function: tree *gimple_cdt_new_type_ptr (gimple g)

Return a pointer to the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE statement G.

— GIMPLE function: void gimple_cdt_set_new_type (gimple g, tree new_type)

Set NEW_TYPE to be the type returned by GIMPLE_CHANGE_DYNAMIC_TYPE statement G.

— GIMPLE function: tree gimple_cdt_location (gimple g)

Return the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement G.

— GIMPLE function: tree *gimple_cdt_location_ptr (gimple g)

Return a pointer to the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement G.

— GIMPLE function: void gimple_cdt_set_location (gimple g, tree ptr)

Set PTR to be the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement G.


Next: , Previous: <code>GIMPLE_CHANGE_DYNAMIC_TYPE</code>, Up: Tuple specific accessors

1.7.7 GIMPLE_COND

— GIMPLE function: gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)

Build a GIMPLE_COND statement. A GIMPLE_COND statement compares LHS and RHS and if the condition in PRED_CODE is true, jump to the label in t_label, otherwise jump to the label in f_label. PRED_CODE are relational operator tree codes like EQ_EXPR, LT_EXPR, LE_EXPR, NE_EXPR, etc.

— GIMPLE function: gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)

Build a GIMPLE_COND statement from the conditional expression tree COND. T_LABEL and F_LABEL are as in gimple_build_cond.

— GIMPLE function: enum tree_code gimple_cond_code (gimple g)

Return the code of the predicate computed by conditional statement G.

— GIMPLE function: void gimple_cond_set_code (gimple g, enum tree_code code)

Set CODE to be the predicate code for the conditional statement G.

— GIMPLE function: tree gimple_cond_lhs (gimple g)

Return the LHS of the predicate computed by conditional statement G.

— GIMPLE function: void gimple_cond_set_lhs (gimple g, tree lhs)

Set LHS to be the LHS operand of the predicate computed by conditional statement G.

— GIMPLE function: tree gimple_cond_rhs (gimple g)

Return the RHS operand of the predicate computed by conditional G.

— GIMPLE function: void gimple_cond_set_rhs (gimple g, tree rhs)

Set RHS to be the RHS operand of the predicate computed by conditional statement G.

— GIMPLE function: tree gimple_cond_true_label (gimple g)

Return the label used by conditional statement G when its predicate evaluates to true.

— GIMPLE function: void gimple_cond_set_true_label (gimple g, tree label)

Set LABEL to be the label used by conditional statement G when its predicate evaluates to true.

— GIMPLE function: void gimple_cond_set_false_label (gimple g, tree label)

Set LABEL to be the label used by conditional statement G when its predicate evaluates to false.

— GIMPLE function: tree gimple_cond_false_label (gimple g)

Return the label used by conditional statement G when its predicate evaluates to false.

— GIMPLE function: void gimple_cond_make_false (gimple g)

Set the conditional COND_STMT to be of the form 'if (1 == 0)'.

— GIMPLE function: void gimple_cond_make_true (gimple g)

Set the conditional COND_STMT to be of the form 'if (1 == 1)'.


Next: , Previous: <code>GIMPLE_COND</code>, Up: Tuple specific accessors

1.7.8 GIMPLE_EH_FILTER

— GIMPLE function: gimple gimple_build_eh_filter (tree types, gimple_seq failure)

Build a GIMPLE_EH_FILTER statement. TYPES are the filter's types. FAILURE is a sequence with the filter's failure action.

— GIMPLE function: tree gimple_eh_filter_types (gimple g)

Return the types handled by GIMPLE_EH_FILTER statement G.

— GIMPLE function: tree *gimple_eh_filter_types_ptr (gimple g)

Return a pointer to the types handled by GIMPLE_EH_FILTER statement G.

— GIMPLE function: gimple_seq gimple_eh_filter_failure (gimple g)

Return the sequence of statement to execute when GIMPLE_EH_FILTER statement fails.

— GIMPLE function: void gimple_eh_filter_set_types (gimple g, tree types)

Set TYPES to be the set of types handled by GIMPLE_EH_FILTER G.

— GIMPLE function: void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)

Set FAILURE to be the sequence of statements to execute on failure for GIMPLE_EH_FILTER G.

— GIMPLE function: bool gimple_eh_filter_must_not_throw (gimple g)

Return the EH_FILTER_MUST_NOT_THROW flag.

— GIMPLE function: void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)

Set the EH_FILTER_MUST_NOT_THROW flag.


Next: , Previous: <code>GIMPLE_EH_FILTER</code>, Up: Tuple specific accessors

1.7.9 GIMPLE_LABEL

— GIMPLE function: gimple gimple_build_label (tree label)

Build a GIMPLE_LABEL statement with corresponding to the tree label, LABEL.

— GIMPLE function: tree gimple_label_label (gimple g)

Return the LABEL_DECL node used by GIMPLE_LABEL statement G.

— GIMPLE function: void gimple_label_set_label (gimple g, tree label)

Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement G.

— GIMPLE function: gimple gimple_build_goto (tree dest)

Build a GIMPLE_GOTO statement to label DEST.

— GIMPLE function: tree gimple_goto_dest (gimple g)

Return the destination of the unconditional jump G.

— GIMPLE function: void gimple_goto_set_dest (gimple g, tree dest)

Set DEST to be the destination of the unconditional jump G.


Next: , Previous: <code>GIMPLE_LABEL</code>, Up: Tuple specific accessors

1.7.10 GIMPLE_NOP

— GIMPLE function: gimple gimple_build_nop (void)

Build a GIMPLE_NOP statement.

— GIMPLE function: bool gimple_nop_p (gimple g)

Returns TRUE if statement G is a GIMPLE_NOP.


Next: , Previous: <code>GIMPLE_NOP</code>, Up: Tuple specific accessors

1.7.11 GIMPLE_OMP_ATOMIC_LOAD

— GIMPLE function: gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)

Build a GIMPLE_OMP_ATOMIC_LOAD statement. LHS is the left-hand side of the assignment. RHS is the right-hand side of the assignment.

— GIMPLE function: void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)

Set the LHS of an atomic load.

— GIMPLE function: tree gimple_omp_atomic_load_lhs (gimple g)

Get the LHS of an atomic load.

— GIMPLE function: void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)

Set the RHS of an atomic set.

— GIMPLE function: tree gimple_omp_atomic_load_rhs (gimple g)

Get the RHS of an atomic set.


Next: , Previous: <code>GIMPLE_OMP_ATOMIC_LOAD</code>, Up: Tuple specific accessors

1.7.12 GIMPLE_OMP_ATOMIC_STORE

— GIMPLE function: gimple gimple_build_omp_atomic_store (tree val)

Build a GIMPLE_OMP_ATOMIC_STORE statement. VAL is the value to be stored.

— GIMPLE function: void gimple_omp_atomic_store_set_val (gimple g, tree val)

Set the value being stored in an atomic store.

— GIMPLE function: tree gimple_omp_atomic_store_val (gimple g)

Return the value being stored in an atomic store.


Next: , Previous: <code>GIMPLE_OMP_ATOMIC_STORE</code>, Up: Tuple specific accessors

1.7.13 GIMPLE_OMP_CONTINUE

— GIMPLE function: gimple gimple_build_omp_continue (tree control_def, tree control_use)

Build a GIMPLE_OMP_CONTINUE statement. CONTROL_DEF is the definition of the control variable. CONTROL_USE is the use of the control variable.

— GIMPLE function: tree gimple_omp_continue_control_def (gimple s)

Return the definition of the control variable on a GIMPLE_OMP_CONTINUE in S.

— GIMPLE function: tree gimple_omp_continue_control_def_ptr (gimple s)

Same as above, but return the pointer.

— GIMPLE function: tree gimple_omp_continue_set_control_def (gimple s)

Set the control variable definition for a GIMPLE_OMP_CONTINUE statement in S.

— GIMPLE function: tree gimple_omp_continue_control_use (gimple s)

Return the use of the control variable on a GIMPLE_OMP_CONTINUE in S.

— GIMPLE function: tree gimple_omp_continue_control_use_ptr (gimple s)

Same as above, but return the pointer.

— GIMPLE function: tree gimple_omp_continue_set_control_use (gimple s)

Set the control variable use for a GIMPLE_OMP_CONTINUE statement in S.


Next: , Previous: <code>GIMPLE_OMP_CONTINUE</code>, Up: Tuple specific accessors

1.7.14 GIMPLE_OMP_CRITICAL

— GIMPLE function: gimple gimple_build_omp_critical (gimple_seq body, tree name)

Build a GIMPLE_OMP_CRITICAL statement. BODY is the sequence of statements for which only one thread can execute. NAME is an optional identifier for this critical block.

— GIMPLE function: tree gimple_omp_critical_name (gimple g)

Return the name associated with OMP_CRITICAL statement G.

— GIMPLE function: tree *gimple_omp_critical_name_ptr (gimple g)

Return a pointer to the name associated with OMP critical statement G.

— GIMPLE function: void gimple_omp_critical_set_name (gimple g, tree name)

Set NAME to be the name associated with OMP critical statement G.


Next: , Previous: <code>GIMPLE_OMP_CRITICAL</code>, Up: Tuple specific accessors

1.7.15 GIMPLE_OMP_FOR

— GIMPLE function: gimple gimple_build_omp_for (gimple_seq body, tree clauses, tree index, tree initial, tree final, tree incr, gimple_seq pre_body, enum tree_code omp_for_cond)

Build a GIMPLE_OMP_FOR statement. BODY is sequence of statements inside the for loop. CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate, lastprivate, reductions, ordered, schedule, and nowait. PRE_BODY is the sequence of statements that are loop invariant. INDEX is the index variable. INITIAL is the initial value of INDEX. FINAL is final value of INDEX. OMP_FOR_COND is the predicate used to compare INDEX and FINAL. INCR is the increment expression.

— GIMPLE function: tree gimple_omp_for_clauses (gimple g)

Return the clauses associated with OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_clauses_ptr (gimple g)

Return a pointer to the OMP_FOR G.

— GIMPLE function: void gimple_omp_for_set_clauses (gimple g, tree clauses)

Set CLAUSES to be the list of clauses associated with OMP_FOR G.

— GIMPLE function: tree gimple_omp_for_index (gimple g)

Return the index variable for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_index_ptr (gimple g)

Return a pointer to the index variable for OMP_FOR G.

— GIMPLE function: void gimple_omp_for_set_index (gimple g, tree index)

Set INDEX to be the index variable for OMP_FOR G.

— GIMPLE function: tree gimple_omp_for_initial (gimple g)

Return the initial value for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_initial_ptr (gimple g)

Return a pointer to the initial value for OMP_FOR G.

— GIMPLE function: void gimple_omp_for_set_initial (gimple g, tree initial)

Set INITIAL to be the initial value for OMP_FOR G.

— GIMPLE function: tree gimple_omp_for_final (gimple g)

Return the final value for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_final_ptr (gimple g)

turn a pointer to the final value for OMP_FOR G.

— GIMPLE function: void gimple_omp_for_set_final (gimple g, tree final)

Set FINAL to be the final value for OMP_FOR G.

— GIMPLE function: tree gimple_omp_for_incr (gimple g)

Return the increment value for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_incr_ptr (gimple g)

Return a pointer to the increment value for OMP_FOR G.

— GIMPLE function: void gimple_omp_for_set_incr (gimple g, tree incr)

Set INCR to be the increment value for OMP_FOR G.

— GIMPLE function: gimple_seq gimple_omp_for_pre_body (gimple g)

Return the sequence of statements to execute before the OMP_FOR statement G starts.

— GIMPLE function: void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)

Set PRE_BODY to be the sequence of statements to execute before the OMP_FOR statement G starts.

— GIMPLE function: void gimple_omp_for_set_cond (gimple g, enum tree_code cond)

Set COND to be the condition code for OMP_FOR G.

— GIMPLE function: enum tree_code gimple_omp_for_cond (gimple g)

Return the condition code associated with OMP_FOR G.


Next: , Previous: <code>GIMPLE_OMP_FOR</code>, Up: Tuple specific accessors

1.7.16 GIMPLE_OMP_MASTER

— GIMPLE function: gimple gimple_build_omp_master (gimple_seq body)

Build a GIMPLE_OMP_MASTER statement. BODY is the sequence of statements to be executed by just the master.


Next: , Previous: <code>GIMPLE_OMP_MASTER</code>, Up: Tuple specific accessors

1.7.17 GIMPLE_OMP_ORDERED

— GIMPLE function: gimple gimple_build_omp_ordered (gimple_seq body)

Build a GIMPLE_OMP_ORDERED statement.

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


Next: , Previous: <code>GIMPLE_OMP_ORDERED</code>, Up: Tuple specific accessors

1.7.18 GIMPLE_OMP_PARALLEL

— GIMPLE function: gimple gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg)

Build a GIMPLE_OMP_PARALLEL statement.

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

— GIMPLE function: bool gimple_omp_parallel_combined_p (gimple g)

Return true if OMP parallel statement G has the GF_OMP_PARALLEL_COMBINED flag set.

— GIMPLE function: void gimple_omp_parallel_set_combined_p (gimple g)

Set the GF_OMP_PARALLEL_COMBINED field in OMP parallel statement G.

— GIMPLE function: gimple_seq gimple_omp_body (gimple g)

Return the body for the OMP statement G.

— GIMPLE function: void gimple_omp_set_body (gimple g, gimple_seq body)

Set BODY to be the body for the OMP statement G.

— GIMPLE function: tree gimple_omp_parallel_clauses (gimple g)

Return the clauses associated with OMP_PARALLEL G.

— GIMPLE function: tree *gimple_omp_parallel_clauses_ptr (gimple g)

Return a pointer to the clauses associated with OMP_PARALLEL G.

— GIMPLE function: void gimple_omp_parallel_set_clauses (gimple g, tree clauses)

Set CLAUSES to be the list of clauses associated with OMP_PARALLEL G.

— GIMPLE function: tree gimple_omp_parallel_child_fn (gimple g)

Return the child function used to hold the body of OMP_PARALLEL G.

— GIMPLE function: tree *gimple_omp_parallel_child_fn_ptr (gimple g)

Return a pointer to the child function used to hold the body of OMP_PARALLEL G.

— GIMPLE function: void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)

Set CHILD_FN to be the child function for OMP_PARALLEL G.

— GIMPLE function: tree gimple_omp_parallel_data_arg (gimple g)

Return the artificial argument used to send variables and values from the parent to the children threads in OMP_PARALLEL G.

— GIMPLE function: tree *gimple_omp_parallel_data_arg_ptr (gimple g)

Return a pointer to the data argument for OMP_PARALLEL G.

— GIMPLE function: void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)

Set DATA_ARG to be the data argument for OMP_PARALLEL G.

— GIMPLE function: bool is_gimple_omp (gimple stmt)

Returns true when the gimple statement STMT is any of the OpenMP types.


Next: , Previous: <code>GIMPLE_OMP_PARALLEL</code>, Up: Tuple specific accessors

1.7.19 GIMPLE_OMP_RETURN

— GIMPLE function: gimple gimple_build_omp_return (bool wait_p)

Build a GIMPLE_OMP_RETURN statement. WAIT_P is true if this is a non-waiting return.

— GIMPLE function: void gimple_omp_return_set_nowait (gimple s)

Set the nowait flag on GIMPLE_OMP_RETURN statement S.

— GIMPLE function: bool gimple_omp_return_nowait_p (gimple g)

Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT flag set.


Next: , Previous: <code>GIMPLE_OMP_RETURN</code>, Up: Tuple specific accessors

1.7.20 GIMPLE_OMP_SECTION

— GIMPLE function: gimple gimple_build_omp_section (gimple_seq body)

Build a GIMPLE_OMP_SECTION statement for a sections statement.

BODY is the sequence of statements in the section.

— GIMPLE function: bool gimple_omp_section_last_p (gimple g)

Return true if OMP section statement G has the GF_OMP_SECTION_LAST flag set.

— GIMPLE function: void gimple_omp_section_set_last (gimple g)

Set the GF_OMP_SECTION_LAST flag on G.


Next: , Previous: <code>GIMPLE_OMP_SECTION</code>, Up: Tuple specific accessors

1.7.21 GIMPLE_OMP_SECTIONS

— GIMPLE function: gimple gimple_build_omp_sections (gimple_seq body, tree clauses)

Build a GIMPLE_OMP_SECTIONS statement. BODY is a sequence of section statements. CLAUSES are any of the OMP sections construct's clauses: private, firstprivate, lastprivate, reduction, and nowait.

— GIMPLE function: gimple gimple_build_omp_sections_switch (void)

Build a GIMPLE_OMP_SECTIONS_SWITCH statement.

— GIMPLE function: tree gimple_omp_sections_control (gimple g)

Return the control variable associated with the GIMPLE_OMP_SECTIONS in G.

— GIMPLE function: tree *gimple_omp_sections_control_ptr (gimple g)

Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS in G.

— GIMPLE function: void gimple_omp_sections_set_control (gimple g, tree control)

Set CONTROL to be the set of clauses associated with the GIMPLE_OMP_SECTIONS in G.

— GIMPLE function: tree gimple_omp_sections_clauses (gimple g)

Return the clauses associated with OMP_SECTIONS G.

— GIMPLE function: tree *gimple_omp_sections_clauses_ptr (gimple g)

Return a pointer to the clauses associated with OMP_SECTIONS G.

— GIMPLE function: void gimple_omp_sections_set_clauses (gimple g, tree clauses)

Set CLAUSES to be the set of clauses associated with OMP_SECTIONS G.


Next: , Previous: <code>GIMPLE_OMP_SECTIONS</code>, Up: Tuple specific accessors

1.7.22 GIMPLE_OMP_SINGLE

— GIMPLE function: gimple gimple_build_omp_single (gimple_seq body, tree clauses)

Build a GIMPLE_OMP_SINGLE statement. BODY is the sequence of statements that will be executed once. CLAUSES are any of the OMP single construct's clauses: private, firstprivate, copyprivate, nowait.

— GIMPLE function: tree gimple_omp_single_clauses (gimple g)

Return the clauses associated with OMP_SINGLE G.

— GIMPLE function: tree *gimple_omp_single_clauses_ptr (gimple g)

Return a pointer to the clauses associated with OMP_SINGLE G.

— GIMPLE function: void gimple_omp_single_set_clauses (gimple g, tree clauses)

Set CLAUSES to be the clauses associated with OMP_SINGLE G.


Next: , Previous: <code>GIMPLE_OMP_SINGLE</code>, Up: Tuple specific accessors

1.7.23 GIMPLE_PHI

— GIMPLE function: gimple make_phi_node (tree var, int len)

Build a PHI node with len argument slots for variable var.

— GIMPLE function: unsigned gimple_phi_capacity (gimple g)

Return the maximum number of arguments supported by GIMPLE_PHI G.

— GIMPLE function: unsigned gimple_phi_num_args (gimple g)

Return the number of arguments in GIMPLE_PHI G. This must always be exactly the number of incoming edges for the basic block holding G.

— GIMPLE function: tree gimple_phi_result (gimple g)

Return the SSA name created by GIMPLE_PHI G.

— GIMPLE function: tree *gimple_phi_result_ptr (gimple g)

Return a pointer to the SSA name created by GIMPLE_PHI G.

— GIMPLE function: void gimple_phi_set_result (gimple g, tree result)

Set RESULT to be the SSA name created by GIMPLE_PHI G.

— GIMPLE function: struct phi_arg_d *gimple_phi_arg (gimple g, index)

Return the PHI argument corresponding to incoming edge INDEX for GIMPLE_PHI G.

— GIMPLE function: void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)

Set PHIARG to be the argument corresponding to incoming edge INDEX for GIMPLE_PHI G.


Next: , Previous: <code>GIMPLE_PHI</code>, Up: Tuple specific accessors

1.7.24 GIMPLE_RESX

— GIMPLE function: gimple gimple_build_resx (int region)

Build a GIMPLE_RESX statement which is a statement. This statement is a placeholder for _Unwind_Resume before we know if a function call or a branch is needed. REGION is the exception region from which control is flowing.

— GIMPLE function: int gimple_resx_region (gimple g)

Return the region number for GIMPLE_RESX G.

— GIMPLE function: void gimple_resx_set_region (gimple g, int region)

Set REGION to be the region number for GIMPLE_RESX G.


Next: , Previous: <code>GIMPLE_RESX</code>, Up: Tuple specific accessors

1.7.25 GIMPLE_RETURN

— GIMPLE function: gimple gimple_build_return (tree retval)

Build a GIMPLE_RETURN statement whose return value is retval.

— GIMPLE function: tree gimple_return_retval (gimple g)

Return the return value for GIMPLE_RETURN G.

— GIMPLE function: void gimple_return_set_retval (gimple g, tree retval)

Set RETVAL to be the return value for GIMPLE_RETURN G.


Next: , Previous: <code>GIMPLE_RETURN</code>, Up: Tuple specific accessors

1.7.26 GIMPLE_SWITCH

— GIMPLE function: gimple gimple_build_switch ( nlabels, tree index, tree default_label, ...)

Build a GIMPLE_SWITCH statement. NLABELS are the number of labels excluding the default label. The default label is passed in DEFAULT_LABEL. The rest of the arguments are trees representing the labels. Each label is a tree of code CASE_LABEL_EXPR.

— GIMPLE function: gimple gimple_build_switch_vec (tree index, tree default_label, VEC(tree,heap) *args)

This function is an alternate way of building GIMPLE_SWITCH statements. INDEX and DEFAULT_LABEL are as in gimple_build_switch. ARGS is a vector of CASE_LABEL_EXPR trees that contain the labels.

— GIMPLE function: unsigned gimple_switch_num_labels (gimple g)

Return the number of labels associated with the switch statement G.

— GIMPLE function: void gimple_switch_set_num_labels (gimple g, unsigned nlabels)

Set NLABELS to be the number of labels for the switch statement G.

— GIMPLE function: tree gimple_switch_index (gimple g)

Return the index variable used by the switch statement G.

— GIMPLE function: void gimple_switch_set_index (gimple g, tree index)

Set INDEX to be the index variable for switch statement G.

— GIMPLE function: tree gimple_switch_label (gimple g, unsigned index)

Return the label numbered INDEX. The default label is 0, followed by any labels in a switch statement.

— GIMPLE function: void gimple_switch_set_label (gimple g, unsigned index, tree label)

Set the label number INDEX to LABEL. 0 is always the default label.

— GIMPLE function: tree gimple_switch_default_label (gimple g)

Return the default label for a switch statement.

— GIMPLE function: void gimple_switch_set_default_label (gimple g, tree label)

Set the default label for a switch statement.


Next: , Previous: <code>GIMPLE_SWITCH</code>, Up: Tuple specific accessors

1.7.27 GIMPLE_TRY

— GIMPLE function: gimple gimple_build_try (gimple_seq eval, gimple_seq cleanup, unsigned int kind)

Build a GIMPLE_TRY statement. EVAL is a sequence with the expression to evaluate. CLEANUP is a sequence of statements to run at clean-up time. KIND is the enumeration value GIMPLE_TRY_CATCH if this statement denotes a try/catch construct or GIMPLE_TRY_FINALLY if this statement denotes a try/finally construct.

— GIMPLE function: enum gimple_try_flags gimple_try_kind (gimple g)

Return the kind of try block represented by GIMPLE_TRY G. This is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.

— GIMPLE function: bool gimple_try_catch_is_cleanup (gimple g)

Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

— GIMPLE function: gimple_seq gimple_try_eval (gimple g)

Return the sequence of statements used as the body for GIMPLE_TRY G.

— GIMPLE function: gimple_seq gimple_try_cleanup (gimple g)

Return the sequence of statements used as the cleanup body for GIMPLE_TRY G.

— GIMPLE function: void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)

Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

— GIMPLE function: void gimple_try_set_eval (gimple g, gimple_seq eval)

Set EVAL to be the sequence of statements to use as the body for GIMPLE_TRY G.

— GIMPLE function: void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)

Set CLEANUP to be the sequence of statements to use as the cleanup body for GIMPLE_TRY G.


Previous: <code>GIMPLE_TRY</code>, Up: Tuple specific accessors

1.7.28 GIMPLE_WITH_CLEANUP_EXPR

— GIMPLE function: gimple gimple_build_wce (gimple_seq cleanup)

Build a GIMPLE_WITH_CLEANUP_EXPR statement. CLEANUP is the clean-up expression.

— GIMPLE function: gimple_seq gimple_wce_cleanup (gimple g)

Return the cleanup sequence for cleanup statement G.

— GIMPLE function: void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)

Set CLEANUP to be the cleanup sequence for G.

— GIMPLE function: bool gimple_wce_cleanup_eh_only (gimple g)

Return the CLEANUP_EH_ONLY flag for a WCE tuple.

— GIMPLE function: void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)

Set the CLEANUP_EH_ONLY flag for a WCE tuple.


Next: , Previous: Tuple specific accessors, Up: GIMPLE

1.8 GIMPLE sequences

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

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

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

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

— GIMPLE function: void gimple_seq_add_stmt (gimple_seq *seq, gimple g)

Link a gimple statement to the end of the sequence *SEQ if G is not NULL. If *SEQ is NULL, allocate a sequence before linking.

— GIMPLE function: void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)

Append sequence SRC to the end of sequence *DEST if SRC is not NULL. If *DEST is NULL, allocate a new sequence before appending.

— GIMPLE function: gimple_seq gimple_seq_deep_copy (gimple_seq src)

Perform a deep copy of sequence SRC and return the result.

— GIMPLE function: gimple_seq gimple_seq_reverse (gimple_seq seq)

Reverse the order of the statements in the sequence SEQ. Return SEQ.

— GIMPLE function: gimple gimple_seq_first (gimple_seq s)

Return the first statement in sequence S.

— GIMPLE function: gimple gimple_seq_last (gimple_seq s)

Return the last statement in sequence S.

— GIMPLE function: void gimple_seq_set_last (gimple_seq s, gimple last)

Set the last statement in sequence S to the statement in LAST.

— GIMPLE function: void gimple_seq_set_first (gimple_seq s, gimple first)

Set the first statement in sequence S to the statement in FIRST.

— GIMPLE function: void gimple_seq_init (gimple_seq s)

Initialize sequence S to an empty sequence.

— GIMPLE function: gimple_seq gimple_seq_alloc (void)

Allocate a new sequence in the garbage collected store and return it.

— GIMPLE function: void gimple_seq_copy (gimple_seq dest, gimple_seq src)

Copy the sequence SRC into the sequence DEST.

— GIMPLE function: bool gimple_seq_empty_p (gimple_seq s)

Return true if the sequence S is empty.

— GIMPLE function: gimple_seq bb_seq (basic_block bb)

Returns the sequence of statements in BB.

— GIMPLE function: void set_bb_seq (basic_block bb, gimple_seq seq)

Sets the sequence of statements in BB to SEQ.

— GIMPLE function: bool gimple_seq_singleton_p (gimple_seq seq)

Determine whether SEQ contains exactly one statement.


Next: , Previous: GIMPLE sequences, Up: GIMPLE

1.9 Sequence iterators

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

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

Backward iterations are possible:

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

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

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

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

— GIMPLE function: gimple_stmt_iterator gsi_start (gimple_seq seq)

Return a new iterator pointing to the sequence SEQ's first statement. If SEQ is empty, the iterator's basic block is NULL. Use gsi_start_bb instead when the iterator needs to always have the correct basic block set.

— GIMPLE function: gimple_stmt_iterator gsi_start_bb (basic_block bb)

Return a new iterator pointing to the first statement in basic block BB.

— GIMPLE function: gimple_stmt_iterator gsi_last (gimple_seq seq)

Return a new iterator initially pointing to the last statement of sequence SEQ. If SEQ is empty, the iterator's basic block is NULL. Use gsi_last_bb instead when the iterator needs to always have the correct basic block set.

— GIMPLE function: gimple_stmt_iterator gsi_last_bb (basic_block bb)

Return a new iterator pointing to the last statement in basic block BB.

— GIMPLE function: bool gsi_end_p (gimple_stmt_iterator i)

Return TRUE if at the end of I.

— GIMPLE function: bool gsi_one_before_end_p (gimple_stmt_iterator i)

Return TRUE if we're one statement before the end of I.

— GIMPLE function: void gsi_next (gimple_stmt_iterator *i)

Advance the iterator to the next gimple statement.

— GIMPLE function: void gsi_prev (gimple_stmt_iterator *i)

Advance the iterator to the previous gimple statement.

— GIMPLE function: gimple gsi_stmt (gimple_stmt_iterator i)

Return the current stmt.

— GIMPLE function: gimple_stmt_iterator gsi_after_labels (basic_block bb)

Return a block statement iterator that points to the first non-label statement in block BB.

— GIMPLE function: gimple *gsi_stmt_ptr (gimple_stmt_iterator *i)

Return a pointer to the current stmt.

— GIMPLE function: basic_block gsi_bb (gimple_stmt_iterator i)

Return the basic block associated with this iterator.

— GIMPLE function: gimple_seq gsi_seq (gimple_stmt_iterator i)

Return the sequence associated with this iterator.

— GIMPLE function: void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)

Remove the current stmt from the sequence. The iterator is updated to point to the next statement. When REMOVE_EH_INFO is true we remove the statement pointed to by iterator I from the EH tables. Otherwise we do not modify the EH tables. Generally, REMOVE_EH_INFO should be true when the statement is going to be removed from the IL and not reinserted elsewhere.

— GIMPLE function: void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)

Links the sequence of statements SEQ before the statement pointed by iterator I. MODE indicates what to do with the iterator after insertion (see enum gsi_iterator_update above).

— GIMPLE function: void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)

Links statement G before the statement pointed-to by iterator I. Updates iterator I according to MODE.

— GIMPLE function: void gsi_link_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)

Links sequence SEQ after the statement pointed-to by iterator I. MODE is as in gsi_insert_after.

— GIMPLE function: void gsi_link_after (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)

Links statement G after the statement pointed-to by iterator I. MODE is as in gsi_insert_after.

— GIMPLE function: gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)

Move all statements in the sequence after I to a new sequence. Return this new sequence.

— GIMPLE function: gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)

Move all statements in the sequence before I to a new sequence. Return this new sequence.

— GIMPLE function: void gsi_replace (gimple_stmt_iterator *i, gimple stmt, bool update_eh_info)

Replace the statement pointed-to by I to STMT. If UPDATE_EH_INFO is true, the exception handling information of the original statement is moved to the new statement.

— GIMPLE function: void gsi_insert_before (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)

Insert statement STMT before the statement pointed-to by iterator I, update STMT's basic block and scan it for new operands. MODE specifies how to update iterator I after insertion (see enum gsi_iterator_update).

— GIMPLE function: void gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)

Like gsi_insert_before, but for all the statements in SEQ.

— GIMPLE function: void gsi_insert_after (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)

Insert statement STMT after the statement pointed-to by iterator I, update STMT's basic block and scan it for new operands. MODE specifies how to update iterator I after insertion (see enum gsi_iterator_update).

— GIMPLE function: void gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)

Like gsi_insert_after, but for all the statements in SEQ.

— GIMPLE function: gimple_stmt_iterator gsi_for_stmt (gimple stmt)

Finds iterator for STMT.

— GIMPLE function: void gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)

Move the statement at FROM so it comes right after the statement at TO.

— GIMPLE function: void gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)

Move the statement at FROM so it comes right before the statement at TO.

— GIMPLE function: void gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)

Move the statement at FROM to the end of basic block BB.

— GIMPLE function: void gsi_insert_on_edge (edge e, gimple stmt)

Add STMT to the pending list of edge E. No actual insertion is made until a call to gsi_commit_edge_inserts() is made.

— GIMPLE function: void gsi_insert_seq_on_edge (edge e, gimple_seq seq)

Add the sequence of statements in SEQ to the pending list of edge E. No actual insertion is made until a call to gsi_commit_edge_inserts() is made.

— GIMPLE function: basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)

Similar to gsi_insert_on_edge+gsi_commit_edge_inserts. If a new block has to be created, it is returned.

— GIMPLE function: void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)

Commit insertions pending at edge E. If a new block is created, set NEW_BB to this block, otherwise set it to NULL.

— GIMPLE function: void gsi_commit_edge_inserts (void)

This routine will commit all pending edge insertions, creating any new basic blocks which are necessary.


Next: , Previous: Sequence iterators, Up: GIMPLE

1.10 Adding a new GIMPLE statement code

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

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

You will probably want to create a function to build the new gimple statement in gimple.c. The function should be called gimple_build_<NEW_TUPLE_NAME>, and should return the new tuple of type gimple.

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


Previous: Adding a new GIMPLE statement code, Up: GIMPLE

1.11 Statement and operand traversals

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

— GIMPLE function: tree walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)

This function is used to walk the current statement in GSI, optionally using traversal state stored in WI. If WI is NULL, no state is kept during the traversal.

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

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

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

— GIMPLE function: tree walk_gimple_op (gimple stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)

Use this function to walk the operands of statement STMT. Every operand is walked via walk_tree with optional state information in WI.

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

              walk_tree (&OP, CALLBACK_OP, WI, WI- PSET)
     

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

— GIMPLE function: tree walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)

This function walks all the statements in the sequence SEQ calling walk_gimple_stmt on each one. WI is as in walk_gimple_stmt. If walk_gimple_stmt returns non-NULL, the walk is stopped and the value returned. Otherwise, all the statements are walked and NULL_TREE returned.


Footnotes

[1] These restrictions are derived from those in Morgan 4.8.