From ae9fd815db6b778af865526a491ab7c02691543e Mon Sep 17 00:00:00 2001 From: Ralf Wildenhues Date: Mon, 10 Jan 2011 19:00:10 +0000 Subject: doc: fix deftypefn markup in gccint manual. gcc/: * doc/gimple.texi: Fix quoting of multi-word return values in @deftypefn statements. Ensure presence of return value. Wrap overlong @deftypefn lines. (is_gimple_operand, is_gimple_min_invariant_address): Remove descriptions of removed functions. * doc/hostconfig.texi (Host Common): Wrap long line, fix quoting of multi-word return value in @deftypefn statement. From-SVN: r168637 --- gcc/doc/gimple.texi | 190 +++++++++++++++++++++++++++------------------------- 1 file changed, 100 insertions(+), 90 deletions(-) (limited to 'gcc/doc/gimple.texi') diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi index d20358a..2cb81c8 100644 --- a/gcc/doc/gimple.texi +++ b/gcc/doc/gimple.texi @@ -613,7 +613,7 @@ Returns the number of operands in statement G. Returns operand @code{I} from statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_ops (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g) Returns a pointer into the operand vector for statement @code{G}. This is computed using an internal table called @code{gimple_ops_offset_}[]. This table is indexed by the gimple code of @code{G}. @@ -638,61 +638,50 @@ vector. These predicates are called by the @code{gimple_@var{name}_set_...()}. Each tuple will use one of the following predicates (Note, this list is not exhaustive): -@deftypefn {GIMPLE function} is_gimple_operand (tree t) -This is the most permissive of the predicates. It essentially -checks whether t has a @code{gimple_rhs_class} of @code{GIMPLE_SINGLE_RHS}. -@end deftypefn - - -@deftypefn {GIMPLE function} is_gimple_val (tree t) +@deftypefn {GIMPLE function} bool is_gimple_val (tree t) Returns true if t is a "GIMPLE value", which are all the non-addressable stack variables (variables for which @code{is_gimple_reg} returns true) and constants (expressions for which @code{is_gimple_min_invariant} returns true). @end deftypefn -@deftypefn {GIMPLE function} is_gimple_addressable (tree t) +@deftypefn {GIMPLE function} bool is_gimple_addressable (tree t) Returns true if t is a symbol or memory reference whose address can be taken. @end deftypefn -@deftypefn {GIMPLE function} is_gimple_asm_val (tree t) +@deftypefn {GIMPLE function} bool is_gimple_asm_val (tree t) Similar to @code{is_gimple_val} but it also accepts hard registers. @end deftypefn -@deftypefn {GIMPLE function} is_gimple_call_addr (tree t) +@deftypefn {GIMPLE function} bool is_gimple_call_addr (tree t) Return true if t is a valid expression to use as the function called by a @code{GIMPLE_CALL}. @end deftypefn -@deftypefn {GIMPLE function} is_gimple_mem_ref_addr (tree t) +@deftypefn {GIMPLE function} bool is_gimple_mem_ref_addr (tree t) Return true if t is a valid expression to use as first operand of a @code{MEM_REF} expression. @end deftypefn -@deftypefn {GIMPLE function} is_gimple_constant (tree t) +@deftypefn {GIMPLE function} bool is_gimple_constant (tree t) Return true if t is a valid gimple constant. @end deftypefn -@deftypefn {GIMPLE function} is_gimple_min_invariant (tree t) +@deftypefn {GIMPLE function} bool is_gimple_min_invariant (tree t) Return true if t is a valid minimal invariant. This is different from constants, in that the specific value of t may not be known at compile time, but it is known that it doesn't change (e.g., the address of a function local variable). @end deftypefn -@deftypefn {GIMPLE function} is_gimple_min_invariant_address (tree t) -Return true if t is an @code{ADDR_EXPR} that does not change once a -function is running. -@end deftypefn - -@deftypefn {GIMPLE function} is_gimple_ip_invariant (tree t) +@deftypefn {GIMPLE function} bool is_gimple_ip_invariant (tree t) Return true if t is an interprocedural invariant. This means that t is a valid invariant in all functions (e.g. it can be an address of a global variable but not of a local one). @end deftypefn -@deftypefn {GIMPLE function} is_gimple_ip_invariant_address (tree t) +@deftypefn {GIMPLE function} bool is_gimple_ip_invariant_address (tree t) Return true if t is an @code{ADDR_EXPR} that does not change once the program is running (and which is valid in all functions). @end deftypefn @@ -700,24 +689,24 @@ program is running (and which is valid in all functions). @subsection Statement validation -@deftypefn {GIMPLE function} is_gimple_assign (gimple g) +@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g) Return true if the code of g is @code{GIMPLE_ASSIGN}. @end deftypefn -@deftypefn {GIMPLE function} is_gimple_call (gimple g) +@deftypefn {GIMPLE function} bool is_gimple_call (gimple g) Return true if the code of g is @code{GIMPLE_CALL}. @end deftypefn -@deftypefn {GIMPLE function} is_gimple_debug (gimple g) +@deftypefn {GIMPLE function} bool is_gimple_debug (gimple g) Return true if the code of g is @code{GIMPLE_DEBUG}. @end deftypefn -@deftypefn {GIMPLE function} gimple_assign_cast_p (gimple g) +@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple g) Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast operation. @end deftypefn -@deftypefn {GIMPLE function} gimple_debug_bind_p (gimple g) +@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g) Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an expression to a variable. @end deftypefn @@ -732,7 +721,7 @@ of the GIMPLE instructions. @subsection Common accessors The following are common accessors for gimple statements. -@deftypefn {GIMPLE function} enum gimple_code gimple_code (gimple g) +@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g) Return the code for statement @code{G}. @end deftypefn @@ -752,7 +741,7 @@ something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and @code{void_type_node}. @end deftypefn -@deftypefn {GIMPLE function} enum tree_code gimple_expr_code (gimple stmt) +@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt) Return the tree code for the expression computed by @code{STMT}. This is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and @code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}. @@ -793,7 +782,7 @@ Return the visited status on statement @code{STMT}. Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}. @end deftypefn -@deftypefn {GIMPLE function} unsigned int gimple_plf (gimple stmt, enum plf_mask plf) +@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf) Return the value of pass local flag @code{PLF} on statement @code{STMT}. @end deftypefn @@ -809,7 +798,7 @@ Return true if statement @code{G} has memory operands. Return the number of operands for statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_ops (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g) Return the array of operands for statement @code{G}. @end deftypefn @@ -817,7 +806,7 @@ Return the array of operands for statement @code{G}. Return operand @code{I} for statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_op_ptr (gimple g, unsigned i) +@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i) Return a pointer to operand @code{I} for statement @code{G}. @end deftypefn @@ -830,7 +819,7 @@ Return the set of symbols that have had their address taken by @code{STMT}. @end deftypefn -@deftypefn {GIMPLE function} struct def_optype_d *gimple_def_ops (gimple g) +@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g) Return the set of @code{DEF} operands for statement @code{G}. @end deftypefn @@ -838,7 +827,7 @@ Return the set of @code{DEF} operands for statement @code{G}. Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} struct use_optype_d *gimple_use_ops (gimple g) +@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g) Return the set of @code{USE} operands for statement @code{G}. @end deftypefn @@ -846,7 +835,7 @@ Return the set of @code{USE} operands for statement @code{G}. Set @code{USE} to be the set of @code{USE} operands for statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} struct voptype_d *gimple_vuse_ops (gimple g) +@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g) Return the set of @code{VUSE} operands for statement @code{G}. @end deftypefn @@ -854,7 +843,7 @@ Return the set of @code{VUSE} operands for statement @code{G}. Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} struct voptype_d *gimple_vdef_ops (gimple g) +@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g) Return the set of @code{VDEF} operands for statement @code{G}. @end deftypefn @@ -951,15 +940,15 @@ Identical to gimple_build_asm, but the arguments are passed in VECs. @end deftypefn -@deftypefn {GIMPLE function} gimple_asm_ninputs (gimple g) +@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g) Return the number of input operands for @code{GIMPLE_ASM} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} gimple_asm_noutputs (gimple g) +@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g) Return the number of output operands for @code{GIMPLE_ASM} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} gimple_asm_nclobbers (gimple g) +@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g) Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}. @end deftypefn @@ -988,7 +977,7 @@ Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} const char *gimple_asm_string (gimple g) +@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple g) Return the string representing the assembly instruction in @code{GIMPLE_ASM} @code{G}. @end deftypefn @@ -1047,13 +1036,13 @@ are the operands. If op2 is null, subcode must be a @code{tree_code} for a unary expression. @end deftypefn -@deftypefn {GIMPLE function} enum tree_code gimple_assign_rhs_code (gimple g) +@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g) Return the code of the expression computed on the @code{RHS} of assignment statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} enum gimple_rhs_class gimple_assign_rhs_class (gimple g) +@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g) Return the gimple rhs class of the code for the expression computed on the rhs of assignment statement @code{G}. This will never return @code{GIMPLE_INVALID_RHS}. @@ -1063,7 +1052,7 @@ return @code{GIMPLE_INVALID_RHS}. Return the @code{LHS} of assignment statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_assign_lhs_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g) Return a pointer to the @code{LHS} of assignment statement @code{G}. @end deftypefn @@ -1071,7 +1060,7 @@ Return a pointer to the @code{LHS} of assignment statement @code{G}. Return the first operand on the @code{RHS} of assignment statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_assign_rhs1_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g) Return the address of the first operand on the @code{RHS} of assignment statement @code{G}. @end deftypefn @@ -1080,7 +1069,7 @@ statement @code{G}. Return the second operand on the @code{RHS} of assignment statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g) Return the address of the second operand on the @code{RHS} of assignment statement @code{G}. @end deftypefn @@ -1089,7 +1078,7 @@ statement @code{G}. Return the third operand on the @code{RHS} of assignment statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_assign_rhs3_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g) Return the address of the third operand on the @code{RHS} of assignment statement @code{G}. @end deftypefn @@ -1202,7 +1191,7 @@ Identical to @code{gimple_build_call} but the arguments are stored in a Return the @code{LHS} of call statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_call_lhs_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g) Return a pointer to the @code{LHS} of call statement @code{G}. @end deftypefn @@ -1243,7 +1232,7 @@ Return the static chain for call statement @code{G}. Set @code{CHAIN} to be the static chain for call statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} gimple_call_num_args (gimple g) +@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g) Return the number of arguments used by call statement @code{G}. @end deftypefn @@ -1252,7 +1241,7 @@ Return the argument at position @code{INDEX} for call statement @code{G}. The first argument is 0. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_call_arg_ptr (gimple g, unsigned index) +@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index) Return a pointer to the argument at position @code{INDEX} for call statement @code{G}. @end deftypefn @@ -1304,7 +1293,7 @@ for the handler. Return the types handled by @code{GIMPLE_CATCH} statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_catch_types_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple g) Return a pointer to the types handled by @code{GIMPLE_CATCH} statement @code{G}. @end deftypefn @@ -1341,7 +1330,7 @@ Build a @code{GIMPLE_COND} statement from the conditional expression tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}. @end deftypefn -@deftypefn {GIMPLE function} enum tree_code gimple_cond_code (gimple g) +@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g) Return the code of the predicate computed by conditional statement @code{G}. @end deftypefn @@ -1452,7 +1441,7 @@ Return the value expression that is bound to a user variable at @code{stmt}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_debug_bind_get_value_ptr (gimple stmt) +@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt) Return a pointer to the value expression that is bound to a user variable at @code{stmt}. @end deftypefn @@ -1489,7 +1478,7 @@ types. @code{FAILURE} is a sequence with the filter's failure action. Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_eh_filter_types_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g) Return a pointer to the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}. @end deftypefn @@ -1658,7 +1647,7 @@ optional identifier for this critical block. Return the name associated with @code{OMP_CRITICAL} statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_critical_name_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (gimple g) Return a pointer to the name associated with @code{OMP} critical statement @code{G}. @end deftypefn @@ -1688,7 +1677,7 @@ compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression. Return the clauses associated with @code{OMP_FOR} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_for_clauses_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g) Return a pointer to the @code{OMP_FOR} @code{G}. @end deftypefn @@ -1700,7 +1689,7 @@ Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @cod Return the index variable for @code{OMP_FOR} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_for_index_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g) Return a pointer to the index variable for @code{OMP_FOR} @code{G}. @end deftypefn @@ -1712,7 +1701,7 @@ Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}. Return the initial value for @code{OMP_FOR} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_for_initial_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g) Return a pointer to the initial value for @code{OMP_FOR} @code{G}. @end deftypefn @@ -1724,7 +1713,7 @@ Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}. Return the final value for @code{OMP_FOR} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_for_final_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g) turn a pointer to the final value for @code{OMP_FOR} @code{G}. @end deftypefn @@ -1736,7 +1725,7 @@ Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}. Return the increment value for @code{OMP_FOR} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_for_incr_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g) Return a pointer to the increment value for @code{OMP_FOR} @code{G}. @end deftypefn @@ -1758,7 +1747,7 @@ the @code{OMP_FOR} statement @code{G} starts. Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} enum tree_code gimple_omp_for_cond (gimple g) +@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g) Return the condition code associated with @code{OMP_FOR} @code{G}. @end deftypefn @@ -1789,7 +1778,8 @@ executed in sequence. @subsection @code{GIMPLE_OMP_PARALLEL} @cindex @code{GIMPLE_OMP_PARALLEL} -@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg) +@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq @ +body, tree clauses, tree child_fn, tree data_arg) Build a @code{GIMPLE_OMP_PARALLEL} statement. @end deftypefn @@ -1820,7 +1810,7 @@ Set @code{BODY} to be the body for the @code{OMP} statement @code{G}. Return the clauses associated with @code{OMP_PARALLEL} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_parallel_clauses_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (gimple g) Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}. @end deftypefn @@ -1834,7 +1824,7 @@ Return the child function used to hold the body of @code{OMP_PARALLEL} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_parallel_child_fn_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (gimple g) Return a pointer to the child function used to hold the body of @code{OMP_PARALLEL} @code{G}. @end deftypefn @@ -1848,7 +1838,7 @@ Return the artificial argument used to send variables and values from the parent to the children threads in @code{OMP_PARALLEL} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_parallel_data_arg_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (gimple g) Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}. @end deftypefn @@ -1921,7 +1911,7 @@ Return the control variable associated with the @code{GIMPLE_OMP_SECTIONS} in @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_sections_control_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g) Return a pointer to the clauses associated with the @code{GIMPLE_OMP_SECTIONS} in @code{G}. @end deftypefn @@ -1935,7 +1925,7 @@ Set @code{CONTROL} to be the set of clauses associated with the Return the clauses associated with @code{OMP_SECTIONS} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_sections_clauses_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g) Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}. @end deftypefn @@ -1960,7 +1950,7 @@ copyprivate, nowait. Return the clauses associated with @code{OMP_SINGLE} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_omp_single_clauses_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g) Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}. @end deftypefn @@ -1991,7 +1981,7 @@ holding @code{G}. Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} tree *gimple_phi_result_ptr (gimple g) +@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g) Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. @end deftypefn @@ -1999,7 +1989,7 @@ Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} struct phi_arg_d *gimple_phi_arg (gimple g, index) +@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index) Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for @code{GIMPLE_PHI} @code{G}. @end deftypefn @@ -2048,7 +2038,8 @@ Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}. @subsection @code{GIMPLE_SWITCH} @cindex @code{GIMPLE_SWITCH} -@deftypefn {GIMPLE function} gimple gimple_build_switch ( nlabels, tree index, tree default_label, ...) +@deftypefn {GIMPLE function} gimple gimple_build_switch (unsigned nlabels, @ +tree index, tree default_label, ...) Build a @code{GIMPLE_SWITCH} statement. @code{NLABELS} are the number of labels excluding the default label. The default label is passed in @code{DEFAULT_LABEL}. The rest of the arguments are trees @@ -2056,7 +2047,8 @@ representing the labels. Each label is a tree of code @code{CASE_LABEL_EXPR}. @end deftypefn -@deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree default_label, @code{VEC}(tree,heap) *args) +@deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree @ +default_label, @code{VEC}(tree,heap) *args) This function is an alternate way of building @code{GIMPLE_SWITCH} statements. @code{INDEX} and @code{DEFAULT_LABEL} are as in gimple_build_switch. @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees @@ -2068,7 +2060,8 @@ Return the number of labels associated with the switch statement @code{G}. @end deftypefn -@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, unsigned nlabels) +@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, @ +unsigned nlabels) Set @code{NLABELS} to be the number of labels for the switch statement @code{G}. @end deftypefn @@ -2086,7 +2079,8 @@ Return the label numbered @code{INDEX}. The default label is 0, followed by any labels in a switch statement. @end deftypefn -@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned index, tree label) +@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned @ +index, tree label) Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default label. @end deftypefn @@ -2095,7 +2089,8 @@ label. Return the default label for a switch statement. @end deftypefn -@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, tree label) +@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, @ +tree label) Set the default label for a switch statement. @end deftypefn @@ -2104,7 +2099,8 @@ Set the default label for a switch statement. @subsection @code{GIMPLE_TRY} @cindex @code{GIMPLE_TRY} -@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, gimple_seq cleanup, unsigned int kind) +@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, @ +gimple_seq cleanup, unsigned int kind) Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the expression to evaluate. @code{CLEANUP} is a sequence of statements to run at clean-up time. @code{KIND} is the enumeration value @@ -2113,7 +2109,7 @@ or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally construct. @end deftypefn -@deftypefn {GIMPLE function} enum gimple_try_flags gimple_try_kind (gimple g) +@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g) Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}. @end deftypefn @@ -2132,7 +2128,8 @@ Return the sequence of statements used as the cleanup body for @code{GIMPLE_TRY} @code{G}. @end deftypefn -@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup) +@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @ +bool catch_is_cleanup) Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag. @end deftypefn @@ -2353,7 +2350,7 @@ Return a block statement iterator that points to the first non-label statement in block @code{BB}. @end deftypefn -@deftypefn {GIMPLE function} gimple *gsi_stmt_ptr (gimple_stmt_iterator *i) +@deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i) Return a pointer to the current stmt. @end deftypefn @@ -2385,12 +2382,14 @@ Links statement @code{G} before the statement pointed-to by iterator @code{I}. Updates iterator @code{I} according to @code{MODE}. @end deftypefn -@deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode) +@deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, @ +gimple_seq seq, enum gsi_iterator_update mode) Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}. @code{MODE} is as in @code{gsi_insert_after}. @end deftypefn -@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode) +@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @ +gimple g, enum gsi_iterator_update mode) Links statement @code{G} after the statement pointed-to by iterator @code{I}. @code{MODE} is as in @code{gsi_insert_after}. @end deftypefn @@ -2405,31 +2404,36 @@ Move all statements in the sequence before @code{I} to a new sequence. Return this new sequence. @end deftypefn -@deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, gimple stmt, bool update_eh_info) +@deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @ +gimple stmt, bool update_eh_info) Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO} is true, the exception handling information of the original statement is moved to the new statement. @end deftypefn -@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode) +@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @ +gimple stmt, enum gsi_iterator_update mode) Insert statement @code{STMT} before the statement pointed-to by iterator @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE} specifies how to update iterator @code{I} after insertion (see enum @code{gsi_iterator_update}). @end deftypefn -@deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode) +@deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, @ +gimple_seq seq, enum gsi_iterator_update mode) Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}. @end deftypefn -@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode) +@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @ +gimple stmt, enum gsi_iterator_update mode) Insert statement @code{STMT} after the statement pointed-to by iterator @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE} specifies how to update iterator @code{I} after insertion (see enum @code{gsi_iterator_update}). @end deftypefn -@deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode) +@deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, @ +gimple_seq seq, enum gsi_iterator_update mode) Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}. @end deftypefn @@ -2437,17 +2441,20 @@ Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}. Finds iterator for @code{STMT}. @end deftypefn -@deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to) +@deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, @ +gimple_stmt_iterator *to) Move the statement at @code{FROM} so it comes right after the statement at @code{TO}. @end deftypefn -@deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to) +@deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, @ +gimple_stmt_iterator *to) Move the statement at @code{FROM} so it comes right before the statement at @code{TO}. @end deftypefn -@deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb) +@deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, @ +basic_block bb) Move the statement at @code{FROM} to the end of basic block @code{BB}. @end deftypefn @@ -2515,7 +2522,8 @@ sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq}, accordingly, and a third function for walking the operands in a statement: @code{walk_gimple_op}. -@deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) +@deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, @ + walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) This function is used to walk the current statement in @code{GSI}, optionally using traversal state stored in @code{WI}. If @code{WI} is @code{NULL}, no state is kept during the traversal. @@ -2535,7 +2543,8 @@ The return value is that returned by the last call to @end deftypefn -@deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) +@deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @ + walk_tree_fn callback_op, struct walk_stmt_info *wi) Use this function to walk the operands of statement @code{STMT}. Every operand is walked via @code{walk_tree} with optional state information in @code{WI}. @@ -2555,7 +2564,8 @@ specified. @end deftypefn -@deftypefn {GIMPLE function} tree walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) +@deftypefn {GIMPLE function} tree walk_gimple_seq (gimple_seq seq, @ + walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) This function walks all the statements in the sequence @code{SEQ} calling @code{walk_gimple_stmt} on each one. @code{WI} is as in @code{walk_gimple_stmt}. If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk -- cgit v1.1