[doc] fix deftypefn markup in gccint manual.

This fixes a number of index entries in gccint.pdf, and avoids a number
of long lines in the input files.

Tested 'make man info pdf html', OK for trunk?

Thanks,
Ralf

doc: fix deftypefn markup in gccint manual.

gcc/ChangeLog:
2011-01-08  Ralf Wildenhues  <Ralf.Wildenhues@gmx.de>

	* doc/gimple.texi: 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.

On Sat, Jan 8, 2011 at 9:03 PM, Ralf Wildenhues <Ralf.Wildenhues@gmx.de> wrote:
> This fixes a number of index entries in gccint.pdf, and avoids a number
> of long lines in the input files.
>
> Tested 'make man info pdf html', OK for trunk?

Ok.

Thanks,
Richard.

> Thanks,
> Ralf
>
> doc: fix deftypefn markup in gccint manual.
>
> gcc/ChangeLog:
> 2011-01-08  Ralf Wildenhues  <Ralf.Wildenhues@gmx.de>
>
>        * doc/gimple.texi: 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.
>
> 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
> diff --git a/gcc/doc/hostconfig.texi b/gcc/doc/hostconfig.texi
> index c02f39b..b00cc54 100644
> --- a/gcc/doc/hostconfig.texi
> +++ b/gcc/doc/hostconfig.texi
> @@ -43,7 +43,8 @@ This host hook is used to set up handling for extra signals.  The most
>  common thing to do in this hook is to detect stack overflow.
>  @end deftypefn
>
> -@deftypefn {Host Hook} void * HOST_HOOKS_GT_PCH_GET_ADDRESS (size_t @var{size}, int @var{fd})
> +@deftypefn {Host Hook} {void *} HOST_HOOKS_GT_PCH_GET_ADDRESS (size_t @
> +  @var{size}, int @var{fd})
>  This host hook returns the address of some space that is likely to be
>  free in some subsequent invocation of the compiler.  We intend to load
>  the PCH data at this address such that the data need not be relocated.
> @@ -52,7 +53,8 @@ The area should be able to hold @var{size} bytes.  If the host uses
>  probing.
>  @end deftypefn
>
> -@deftypefn {Host Hook} int HOST_HOOKS_GT_PCH_USE_ADDRESS (void * @var{address}, size_t @var{size}, int @var{fd}, size_t @var{offset})
> +@deftypefn {Host Hook} int HOST_HOOKS_GT_PCH_USE_ADDRESS (void * @var{address}, @
> +  size_t @var{size}, int @var{fd}, size_t @var{offset})
>  This host hook is called when a PCH file is about to be loaded.
>  We want to load @var{size} bytes from @var{fd} at @var{offset}
>  into memory at @var{address}.  The given address will be the result of
>