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;
     };

       T1 = b + 5;
       a = T1;

       a = b + c + d

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

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

       a = b ? c : d;

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

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

     a = b + c

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

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

— 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.

— 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.

— 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

— 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.

— 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.

— 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.

— 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.

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

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

— GIMPLE function: tree gimple_bind_vars (gimple g)

Return the variables declared in the GIMPLE_BIND statement G.

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

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

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

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

— GIMPLE function: gimple_seq gimple_bind_body (gimple g)

Return the GIMPLE sequence contained in the GIMPLE_BIND statement G.

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

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

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

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

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

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

— GIMPLE function: tree gimple_bind_block (gimple g)

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

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

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

— GIMPLE 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.

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

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

— GIMPLE function: tree gimple_catch_types (gimple g)

Return the types handled by GIMPLE_CATCH statement G.

— GIMPLE function: tree *gimple_catch_types_ptr (gimple g)

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

— GIMPLE function: gimple_seq gimple_catch_handler (gimple g)

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

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

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

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

Set HANDLER to be the body of GIMPLE_CATCH G.

— GIMPLE 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.

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

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

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

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

— GIMPLE function: enum tree_code gimple_cond_code (gimple g)

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

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

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

— GIMPLE function: tree gimple_cond_lhs (gimple g)

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

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

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

— GIMPLE function: tree gimple_cond_rhs (gimple g)

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

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

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

— GIMPLE function: tree gimple_cond_true_label (gimple g)

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

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

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

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

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

— GIMPLE function: tree gimple_cond_false_label (gimple g)

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

— GIMPLE function: void gimple_cond_make_false (gimple g)

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

— GIMPLE function: void gimple_cond_make_true (gimple g)

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

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

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

— GIMPLE function: tree gimple_eh_filter_types (gimple g)

Return the types handled by GIMPLE_EH_FILTER statement G.

— GIMPLE function: tree *gimple_eh_filter_types_ptr (gimple g)

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

— GIMPLE function: gimple_seq gimple_eh_filter_failure (gimple g)

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

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

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

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

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

— GIMPLE function: bool gimple_eh_filter_must_not_throw (gimple g)

Return the EH_FILTER_MUST_NOT_THROW flag.

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

Set the EH_FILTER_MUST_NOT_THROW flag.

— GIMPLE function: gimple gimple_build_label (tree label)

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

— GIMPLE function: tree gimple_label_label (gimple g)

Return the LABEL_DECL node used by GIMPLE_LABEL statement G.

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

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

— GIMPLE function: gimple gimple_build_goto (tree dest)

Build a GIMPLE_GOTO statement to label DEST.

— GIMPLE function: tree gimple_goto_dest (gimple g)

Return the destination of the unconditional jump G.

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

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

— GIMPLE function: gimple gimple_build_nop (void)

Build a GIMPLE_NOP statement.

— GIMPLE function: bool gimple_nop_p (gimple g)

Returns TRUE if statement G is a GIMPLE_NOP.

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

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

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

Set the LHS of an atomic load.

— GIMPLE function: tree gimple_omp_atomic_load_lhs (gimple g)

Get the LHS of an atomic load.

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

Set the RHS of an atomic set.

— GIMPLE function: tree gimple_omp_atomic_load_rhs (gimple g)

Get the RHS of an atomic set.

— GIMPLE function: gimple gimple_build_omp_atomic_store (tree val)

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

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

Set the value being stored in an atomic store.

— GIMPLE function: tree gimple_omp_atomic_store_val (gimple g)

Return the value being stored in an atomic store.

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

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

— GIMPLE function: tree gimple_omp_continue_control_def (gimple s)

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

— GIMPLE function: tree gimple_omp_continue_control_def_ptr (gimple s)

Same as above, but return the pointer.

— GIMPLE function: tree gimple_omp_continue_set_control_def (gimple s)

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

— GIMPLE function: tree gimple_omp_continue_control_use (gimple s)

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

— GIMPLE function: tree gimple_omp_continue_control_use_ptr (gimple s)

Same as above, but return the pointer.

— GIMPLE function: tree gimple_omp_continue_set_control_use (gimple s)

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

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

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

— GIMPLE function: tree gimple_omp_critical_name (gimple g)

Return the name associated with OMP_CRITICAL statement G.

— GIMPLE function: tree *gimple_omp_critical_name_ptr (gimple g)

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

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

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

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

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

— GIMPLE function: tree gimple_omp_for_clauses (gimple g)

Return the clauses associated with OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_clauses_ptr (gimple g)

Return a pointer to the OMP_FOR G.

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

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

— GIMPLE function: tree gimple_omp_for_index (gimple g)

Return the index variable for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_index_ptr (gimple g)

Return a pointer to the index variable for OMP_FOR G.

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

Set INDEX to be the index variable for OMP_FOR G.

— GIMPLE function: tree gimple_omp_for_initial (gimple g)

Return the initial value for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_initial_ptr (gimple g)

Return a pointer to the initial value for OMP_FOR G.

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

Set INITIAL to be the initial value for OMP_FOR G.

— GIMPLE function: tree gimple_omp_for_final (gimple g)

Return the final value for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_final_ptr (gimple g)

turn a pointer to the final value for OMP_FOR G.

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

Set FINAL to be the final value for OMP_FOR G.

— GIMPLE function: tree gimple_omp_for_incr (gimple g)

Return the increment value for OMP_FOR G.

— GIMPLE function: tree *gimple_omp_for_incr_ptr (gimple g)

Return a pointer to the increment value for OMP_FOR G.

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

Set INCR to be the increment value for OMP_FOR G.

— GIMPLE function: gimple_seq gimple_omp_for_pre_body (gimple g)

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

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

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

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

Set COND to be the condition code for OMP_FOR G.

— GIMPLE function: enum tree_code gimple_omp_for_cond (gimple g)

Return the condition code associated with OMP_FOR G.

— GIMPLE function: gimple gimple_build_omp_master (gimple_seq body)

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

— GIMPLE function: gimple gimple_build_omp_ordered (gimple_seq body)

Build a GIMPLE_OMP_ORDERED statement.

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

Build a GIMPLE_OMP_PARALLEL statement.

— 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.

— GIMPLE function: gimple gimple_build_omp_return (bool wait_p)

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

— GIMPLE function: void gimple_omp_return_set_nowait (gimple s)

Set the nowait flag on GIMPLE_OMP_RETURN statement S.

— GIMPLE function: bool gimple_omp_return_nowait_p (gimple g)

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

— GIMPLE function: gimple gimple_build_omp_section (gimple_seq body)

Build a GIMPLE_OMP_SECTION statement for a sections statement.

— GIMPLE function: bool gimple_omp_section_last_p (gimple g)

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

— GIMPLE function: void gimple_omp_section_set_last (gimple g)

Set the GF_OMP_SECTION_LAST flag on G.

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

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

— GIMPLE function: gimple gimple_build_omp_sections_switch (void)

Build a GIMPLE_OMP_SECTIONS_SWITCH statement.

— GIMPLE function: tree gimple_omp_sections_control (gimple g)

Return the control variable associated with the GIMPLE_OMP_SECTIONS in G.

— GIMPLE function: tree *gimple_omp_sections_control_ptr (gimple g)

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

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

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

— GIMPLE function: tree gimple_omp_sections_clauses (gimple g)

Return the clauses associated with OMP_SECTIONS G.

— GIMPLE function: tree *gimple_omp_sections_clauses_ptr (gimple g)

Return a pointer to the clauses associated with OMP_SECTIONS G.

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

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

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

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

— GIMPLE function: tree gimple_omp_single_clauses (gimple g)

Return the clauses associated with OMP_SINGLE G.

— GIMPLE function: tree *gimple_omp_single_clauses_ptr (gimple g)

Return a pointer to the clauses associated with OMP_SINGLE G.

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

Set CLAUSES to be the clauses associated with OMP_SINGLE G.

— GIMPLE 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.

— GIMPLE function: gimple gimple_build_resx (int region)

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

— GIMPLE function: int gimple_resx_region (gimple g)

Return the region number for GIMPLE_RESX G.

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

Set REGION to be the region number for GIMPLE_RESX G.

— GIMPLE function: gimple gimple_build_return (tree retval)

Build a GIMPLE_RETURN statement whose return value is retval.

— GIMPLE function: tree gimple_return_retval (gimple g)

Return the return value for GIMPLE_RETURN G.

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

Set RETVAL to be the return value for GIMPLE_RETURN G.

— GIMPLE 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.

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

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

— GIMPLE function: enum gimple_try_flags gimple_try_kind (gimple g)

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

— GIMPLE function: bool gimple_try_catch_is_cleanup (gimple g)

Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

— GIMPLE function: gimple_seq gimple_try_eval (gimple g)

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

— GIMPLE function: gimple_seq gimple_try_cleanup (gimple g)

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

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

Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

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

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

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

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

— GIMPLE function: gimple gimple_build_wce (gimple_seq cleanup)

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

— GIMPLE function: gimple_seq gimple_wce_cleanup (gimple g)

Return the cleanup sequence for cleanup statement G.

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

Set CLEANUP to be the cleanup sequence for G.

— GIMPLE function: bool gimple_wce_cleanup_eh_only (gimple g)

Return the CLEANUP_EH_ONLY flag for a WCE tuple.

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

Set the CLEANUP_EH_ONLY flag for a WCE tuple.

— GIMPLE 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.

     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.  */
       }

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

— 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.

— 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.