This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[patch] Edits for GCC internals manual - gimple.texi


Mix of editorial fixes for GCC Internals manual. 

Mainly changes @code{FOO} to @var{foo} for function arguments.
A few places where braces were added to allow texinfo to find the function name
A few places where the function signature was incomplete
A couple of places where part of the documentation wasn't included in a 
@deftypefn / @end deftypefn pair (which messes with the indentation in the HTML
form, at least)

Brad


Index: doc/gimple.texi
===================================================================
--- doc/gimple.texi	(revision 147052)
+++ doc/gimple.texi	(working copy)
@@ -613,13 +613,13 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
-Returns operand @code{I} from statement @code{G}.
+Returns operand @var{i} from statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
-Returns a pointer into the operand vector for statement @code{G}.  This
+Returns a pointer into the operand vector for statement @var{g}.  This
 is computed using an internal table called @code{gimple_ops_offset_}[].
-This table is indexed by the gimple code of @code{G}.
+This table is indexed by the gimple code of @var{g}.
 
 When the compiler is built, this table is filled-in using the
 sizes of the structures used by each statement code defined in
@@ -688,15 +688,15 @@
 @subsection Statement validation
 
 @deftypefn {GIMPLE function} is_gimple_assign (gimple g)
-Return true if the code of g is @code{GIMPLE_ASSIGN}.
+Return true if the code of @var{g} is @code{GIMPLE_ASSIGN}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} is_gimple_call (gimple g)
-Return true if the code of g is @code{GIMPLE_CALL}
+Return true if the code of @var{g} is @code{GIMPLE_CALL}
 @end deftypefn
  
 @deftypefn {GIMPLE function} gimple_assign_cast_p (gimple g)
-Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
+Return true if @var{g} is a @code{GIMPLE_ASSIGN} that performs a type cast
 operation
 @end deftypefn
 
@@ -710,169 +710,169 @@
 @subsection Common accessors 
 The following are common accessors for gimple statements.
 
-@deftypefn {GIMPLE function} enum gimple_code gimple_code (gimple g)
-Return the code for statement @code{G}.
+@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
+Return the code for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
-Return the basic block to which statement @code{G} belongs to.
+Return the basic block to which statement @var{g} belongs to.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_block (gimple g)
-Return the lexical scope block holding statement @code{G}.
+Return the lexical scope block holding statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
-Return the type of the main expression computed by @code{STMT}. Return
-@code{void_type_node} if @code{STMT} computes nothing. This will only return
+Return the type of the main expression computed by @var{stmt}. Return
+@code{void_type_node} if @var{stmt} computes nothing. This will only return
 something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
 @code{GIMPLE_CALL}.  For all other tuple codes, it will return
 @code{void_type_node}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} enum tree_code gimple_expr_code (gimple stmt)
-Return the tree code for the expression computed by @code{STMT}.  This
+@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
+Return the tree code for the expression computed by @var{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}.
+@code{GIMPLE_COND}.  If @var{stmt} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
 For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
 For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
 by the @code{RHS} of the assignment.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
-Set the lexical scope block of @code{G} to @code{BLOCK}.
+Set the lexical scope block of @var{g} to @var{block}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
-Return locus information for statement @code{G}.
+Return locus information for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
-Set locus information for statement @code{G}.
+Set locus information for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
-Return true if @code{G} does not have locus information.
+Return true if @var{g} does not have locus information.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
-Return true if no warnings should be emitted for statement @code{STMT}.
+Return true if no warnings should be emitted for statement @var{stmt}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
-Set the visited status on statement @code{STMT} to @code{VISITED_P}.
+Set the visited status on statement @var{stmt} to @var{visited_p}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
-Return the visited status on statement @code{STMT}.
+Return the visited status on statement @var{stmt}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
-Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
+Set pass local flag @var{plf} on statement @var{stmt} to @code{val_p}.
 @end deftypefn
  
-@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}.
+@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
+Return the value of pass local flag @var{plf} on statement @var{stmt}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
-Return true if statement @code{G} has register or memory operands.
+Return true if statement @var{g} has register or memory operands.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
-Return true if statement @code{G} has memory operands.
+Return true if statement @var{g} has memory operands.
 @end deftypefn
  
 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
-Return the number of operands for statement @code{G}.
+Return the number of operands for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
-Return the array of operands for statement @code{G}.
+Return the array of operands for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
-Return operand @code{I} for statement @code{G}.
+Return operand @var{i} for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree *gimple_op_ptr (gimple g, unsigned i)
-Return a pointer to operand @code{I} for statement @code{G}.
+Return a pointer to operand @var{i} for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
-Set operand @code{I} of statement @code{G} to @code{OP}.
+Set operand @var{i} of statement @var{g} to @var{op}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
 Return the set of symbols that have had their address taken by
-@code{STMT}.
+@var{stmt}.
 @end deftypefn
  
-@deftypefn {GIMPLE function} struct def_optype_d *gimple_def_ops (gimple g)
-Return the set of @code{DEF} operands for statement @code{G}.
+@deftypefn {GIMPLE function} {struct def_optype_d} *gimple_def_ops (gimple g)
+Return the set of @code{DEF} operands for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
-Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
+Set @var{def} to be the set of @code{DEF} operands for statement @var{g}.
 @end deftypefn
  
-@deftypefn {GIMPLE function} struct use_optype_d *gimple_use_ops (gimple g)
-Return the set of @code{USE} operands for statement @code{G}.
+@deftypefn {GIMPLE function} {struct use_optype_d} *gimple_use_ops (gimple g)
+Return the set of @code{USE} operands for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
-Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
+Set @var{use} to be the set of @code{USE} operands for statement @var{g}.
 @end deftypefn
  
-@deftypefn {GIMPLE function} struct voptype_d *gimple_vuse_ops (gimple g)
-Return the set of @code{VUSE} operands for statement @code{G}.
+@deftypefn {GIMPLE function} {struct voptype_d} *gimple_vuse_ops (gimple g)
+Return the set of @code{VUSE} operands for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
-Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
+Set @var{ops} to be the set of @code{VUSE} operands for statement @var{g}.
 @end deftypefn
  
-@deftypefn {GIMPLE function} struct voptype_d *gimple_vdef_ops (gimple g)
-Return the set of @code{VDEF} operands for statement @code{G}.
+@deftypefn {GIMPLE function} {struct voptype_d} *gimple_vdef_ops (gimple g)
+Return the set of @code{VDEF} operands for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
-Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
+Set @var{ops} to be the set of @code{VDEF} operands for statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
-Return the set of symbols loaded by statement @code{G}.  Each element of
+Return the set of symbols loaded by statement @var{g}.  Each element of
 the set is the @code{DECL_UID} of the corresponding symbol.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
-Return the set of symbols stored by statement @code{G}.  Each element of
+Return the set of symbols stored by statement @var{g}.  Each element of
 the set is the @code{DECL_UID} of the corresponding symbol.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
-Return true if statement @code{G} has operands and the modified field
+Return true if statement @var{g} has operands and the modified field
 has been set.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
-Return true if statement @code{STMT} contains volatile operands.
+Return true if statement @var{stmt} contains volatile operands.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
-Return true if statement @code{STMT} contains volatile operands.
+Return true if statement @var{stmt} contains volatile operands.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void update_stmt (gimple s)
-Mark statement @code{S} as modified, and update it.
+Mark statement @var{s} as modified, and update it.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
-Update statement @code{S} if it has been marked modified.
+Update statement @var{s} if it has been marked modified.
 @end deftypefn
  
 @deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
-Return a deep copy of statement @code{STMT}.
+Return a deep copy of statement @var{stmt}.
 @end deftypefn
 
 @node Tuple specific accessors
@@ -917,10 +917,10 @@
 
 @deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
 Build a @code{GIMPLE_ASM} statement.  This statement is used for
-building in-line assembly constructs.  @code{STRING} is the assembly
-code.  @code{NINPUT} is the number of register inputs.  @code{NOUTPUT} is the
-number of register outputs.  @code{NCLOBBERS} is the number of clobbered
-registers.  The rest of the arguments trees for each input,
+building in-line assembly constructs.  @var{string} is the assembly
+code.  @var{ninputs} is the number of register inputs.  @var{noutputs} is the
+number of register outputs.  @var{nclobbers} is the number of clobbered
+registers.  The rest of the arguments are trees for each input,
 output, and clobbered registers.
 @end deftypefn
 
@@ -929,58 +929,58 @@
 VECs.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_asm_ninputs (gimple g)
-Return the number of input operands for @code{GIMPLE_ASM} @code{G}. 
+@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g)
+Return the number of input operands for @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_asm_noutputs (gimple g)
-Return the number of output operands for @code{GIMPLE_ASM} @code{G}. 
+@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g)
+Return the number of output operands for @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_asm_nclobbers (gimple g)
-Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}. 
+@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g)
+Return the number of clobber operands for @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
-Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 
+Return input operand @code{index} of @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
-Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 
+Set @code{in_op} to be input operand @code{index} in @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
-Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 
+Return output operand @var{index} of @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
 unsigned index, tree out_op)
-Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 
+Set @var{out_op} to be output operand @var{index} in @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
-Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 
+Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
-Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 
+Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @var{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}. 
+@code{GIMPLE_ASM} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
-Return true if @code{G} is an asm statement marked volatile. 
+Return true if @var{g} is an asm statement marked volatile.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
-Mark asm statement @code{G} as volatile. 
+Mark asm statement @var{g} as volatile.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
-Remove volatile marker from asm statement @code{G}. 
+Remove volatile marker from asm statement @var{g}.
 @end deftypefn
 
 @node @code{GIMPLE_ASSIGN}
@@ -989,8 +989,8 @@
 
 @deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
 Build a @code{GIMPLE_ASSIGN} statement.  The left-hand side is an lvalue
-passed in lhs.  The right-hand side can be either a unary or
-binary tree expression.  The expression tree rhs will be
+passed in @var{lhs}.  The right-hand side can be either a unary or
+binary tree expression.  The expression tree @var{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
@@ -1003,14 +1003,14 @@
 
 @deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
-@code{*SEQ_P}.
-@end deftypefn
+@var{*seq_p}.
 
-@code{DST}/@code{SRC} are the destination and source respectively.  You can
-pass ungimplified trees in @code{DST} or @code{SRC}, in which
+@var{dst} and @var{src} are the destination and source respectively.  You can
+pass ungimplified trees in @var{dst} or @var{src}, in which
 case they will be converted to a gimple operand if necessary.
 
 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
+@end deftypefn
 
 @deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
 (enum tree_code subcode, tree lhs, tree op1, tree op2)
@@ -1019,75 +1019,75 @@
 right-hand side of the assignment are already split into
 different operands.
 
-The left-hand side is an lvalue passed in lhs.  Subcode is the
-@code{tree_code} for the right-hand side of the assignment.  Op1 and op2
-are the operands.  If op2 is null, subcode must be a @code{tree_code}
+The left-hand side is an lvalue passed in @var{lhs}.  @var{subcode} is the
+@code{tree_code} for the right-hand side of the assignment.  @var{op1} and @var{op2}
+are the operands.  If @var{op2} is null, @var{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}.
+assignment statement @var{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
+computed on the rhs of assignment statement @var{g}.  This will never
 return @code{GIMPLE_INVALID_RHS}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
-Return the @code{LHS} of assignment statement @code{G}.
+Return the @code{LHS} of assignment statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree *gimple_assign_lhs_ptr (gimple g)
-Return a pointer to the @code{LHS} of assignment statement @code{G}.
+Return a pointer to the @code{LHS} of assignment statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
-Return the first operand on the @code{RHS} of assignment statement @code{G}.
+Return the first operand on the @code{RHS} of assignment statement @var{g}.
 @end deftypefn
  
 @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}.
+statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
-Return the second operand on the @code{RHS} of assignment statement @code{G}.
+Return the second operand on the @code{RHS} of assignment statement @var{g}.
 @end deftypefn
  
 @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}.
+statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
-Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
+Set @code{LHS} to be the @code{LHS} operand of assignment statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
-statement @code{G}.
+statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
-Return the second operand on the @code{RHS} of assignment statement @code{G}.
+Return the second operand on the @code{RHS} of assignment statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
 Return a pointer to the second operand on the @code{RHS} of assignment
-statement @code{G}.
+statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
-statement @code{G}.
+statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
-Return true if @code{S} is a type-cast assignment.
+Return true if @var{s} is a type-cast assignment.
 @end deftypefn
 
 
@@ -1096,31 +1096,31 @@
 @cindex @code{GIMPLE_BIND}
 
 @deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
-Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
-and a body of statements in sequence @code{BODY}.
+Build a @code{GIMPLE_BIND} statement with a list of variables in @var{vars}
+and a body of statements in sequence @var{body}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
-Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}. 
+Return the variables declared in the @code{GIMPLE_BIND} statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
-Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
-statement @code{G}. 
+Set @var{vars} to be the set of variables declared in the @code{GIMPLE_BIND}
+statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
-Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
-statement @code{G}.
+Append @var{vars} to the set of variables declared in the @code{GIMPLE_BIND}
+statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
-@code{G}. 
+@var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
-Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
+Set @var{seq} to be sequence contained in the @code{GIMPLE_BIND} statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
@@ -1134,12 +1134,12 @@
 
 @deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
-@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees. 
+@var{g}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
-Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
-statement @code{G}. 
+Set @var{block} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
+statement @var{g}.
 @end deftypefn
 
 
@@ -1148,21 +1148,21 @@
 @cindex @code{GIMPLE_CALL}
 
 @deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
-Build a @code{GIMPLE_CALL} statement to function @code{FN}.  The argument @code{FN}
+Build a @code{GIMPLE_CALL} statement to function @var{fn}.  The argument @var{fn}
 must be either a @code{FUNCTION_DECL} or a gimple call address as
-determined by @code{is_gimple_call_addr}.  @code{NARGS} are the number of
-arguments.  The rest of the arguments follow the argument @code{NARGS},
+determined by @code{is_gimple_call_addr}.  @var{nargs} is the number of
+arguments.  The rest of the arguments follow the argument @var{nargs},
 and must be trees that are valid as rvalues in gimple (i.e., each
 operand is validated with @code{is_gimple_operand}).
 @end deftypefn
 
 
 @deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
-Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node.  The arguments and the
+Build a @code{GIMPLE_CALL} from a @var{call_expr} node.  The arguments and the
 function are taken from the expression directly.  This routine
-assumes that @code{call_expr} is already in GIMPLE form.  That is, its
+assumes that @var{call_expr} is already in GIMPLE form.  That is, its
 operands are GIMPLE values and the function call needs no further
-simplification.  All the call flags in @code{call_expr} are copied over
+simplification.  All the call flags in @var{call_expr} are copied over
 to the new @code{GIMPLE_CALL}.
 @end deftypefn
 
@@ -1172,24 +1172,24 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
-Return the @code{LHS} of call statement @code{G}.
+Return the @code{LHS} of call statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree *gimple_call_lhs_ptr (gimple g)
-Return a pointer to the @code{LHS} of call statement @code{G}.
+Return a pointer to the @code{LHS} of call statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
-Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
+Set @var{lhs} to be the @code{LHS} operand of call statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
 Return the tree node representing the function called by call
-statement @code{G}.
+statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
-Set @code{FN} to be the function called by call statement @code{G}.  This has
+Set @var{fn} to be the function called by call statement @var{g}.  This has
 to be a gimple value specifying the address of the called
 function.
 @end deftypefn
@@ -1201,65 +1201,65 @@
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
-Set the called function to @code{FNDECL}.
+Set the called function to @var{fndecl}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
-Return the type returned by call statement @code{G}.
+Return the type returned by call statement @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
-Return the static chain for call statement @code{G}. 
+Return the static chain for call statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
-Set @code{CHAIN} to be the static chain for call statement @code{G}. 
+Set @var{chain} to be the static chain for call statement @var{g}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} gimple_call_num_args (gimple g)
-Return the number of arguments used by call statement @code{G}. 
+@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
+Return the number of arguments used by call statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
-Return the argument at position @code{INDEX} for call statement @code{G}.  The
+Return the argument at position @var{index} for call statement @var{g}.  The
 first argument is 0.
 @end deftypefn
  
 @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}. 
+Return a pointer to the argument at position @var{index} for call
+statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
-Set @code{ARG} to be the argument at position @code{INDEX} for call statement
-@code{G}. 
+Set @var{arg} to be the argument at position @var{index} for call statement
+@var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
-Mark call statement @code{S} as being a tail call (i.e., a call just
+Mark call statement @var{s} as being a tail call (i.e., a call just
 before the exit of a function). These calls are candidate for
 tail call optimization. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
-Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call. 
+Return true if @code{GIMPLE_CALL} @var{s} is marked as a tail call.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
-Mark @code{GIMPLE_CALL} @code{S} as being uninlinable. 
+Mark @code{GIMPLE_CALL} @var{s} as being uninlinable.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
-Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined. 
+Return true if @code{GIMPLE_CALL} @var{s} cannot be inlined.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
-Return true if @code{S} is a noreturn call. 
+Return true if @var{s} is a noreturn call.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
-Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
-in the positions marked by the set @code{ARGS_TO_SKIP}.
+Build a @code{GIMPLE_CALL} identical to @var{stmt} but skipping the arguments
+in the positions marked by the set @var{args_to_skip}.
 @end deftypefn
 
 
@@ -1268,31 +1268,31 @@
 @cindex @code{GIMPLE_CATCH}
 
 @deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
-Build a @code{GIMPLE_CATCH} statement.  @code{TYPES} are the tree types this
-catch handles.  @code{HANDLER} is a sequence of statements with the code
+Build a @code{GIMPLE_CATCH} statement.  @var{types} are the tree types this
+catch handles.  @var{handler} is a sequence of statements with the code
 for the handler.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
-Return the types handled by @code{GIMPLE_CATCH} statement @code{G}. 
+Return the types handled by @code{GIMPLE_CATCH} statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_catch_types_ptr (gimple g)
 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
-@code{G}. 
+@var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
 Return the GIMPLE sequence representing the body of the handler
-of @code{GIMPLE_CATCH} statement @code{G}. 
+of @code{GIMPLE_CATCH} statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
-Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}. 
+Set @var{t} to be the set of types handled by @code{GIMPLE_CATCH} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
-Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}. 
+Set @var{handler} to be the body of @code{GIMPLE_CATCH} @var{g}.
 @end deftypefn
 
 @node @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
@@ -1300,38 +1300,38 @@
 @cindex @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
 
 @deftypefn {GIMPLE function} gimple gimple_build_cdt (tree type, tree ptr)
-Build a @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement.  @code{TYPE} is the new
-type for the location @code{PTR}.
+Build a @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement.  @var{type} is the new
+type for the location @var{ptr}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_cdt_new_type (gimple g)
 Return the new type set by @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement
-@code{G}. 
+@var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_cdt_new_type_ptr (gimple g)
 Return a pointer to the new type set by
-@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. 
+@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_cdt_set_new_type (gimple g, tree new_type)
-Set @code{NEW_TYPE} to be the type returned by
-@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. 
+Set @var{new_type} to be the type returned by
+@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_cdt_location (gimple g)
 Return the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
-statement @code{G}. 
+statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_cdt_location_ptr (gimple g)
 Return a pointer to the location affected by
-@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}. 
+@code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_cdt_set_location (gimple g, tree ptr)
-Set @code{PTR} to be the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
-statement @code{G}. 
+Set @var{ptr} to be the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
+statement @var{g}. 
 @end deftypefn
 
 
@@ -1340,66 +1340,66 @@
 @cindex @code{GIMPLE_COND}
 
 @deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
-Build a @code{GIMPLE_COND} statement.  @code{A} @code{GIMPLE_COND} statement compares
-@code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
-the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
-@code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
+Build a @code{GIMPLE_COND} statement.  A @code{GIMPLE_COND} statement compares
+@var{lhs} and @var{rhs} and if the condition in @var{pred_code} is true, jump to
+the label in @var{t_label}, otherwise jump to the label in @var{f_label}.
+@var{pred_code} are relational operator tree codes like @code{EQ_EXPR},
 @code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
 @end deftypefn
 
 
 @deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
 Build a @code{GIMPLE_COND} statement from the conditional expression
-tree @code{COND}.  @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
+tree @var{cond}.  @var{t_label} and @var{f_label} are as in @code{gimple_build_cond}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} enum tree_code gimple_cond_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
 Return the code of the predicate computed by conditional
-statement @code{G}. 
+statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
-Set @code{CODE} to be the predicate code for the conditional statement
-@code{G}. 
+Set @var{code} to be the predicate code for the conditional statement
+@var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
 Return the @code{LHS} of the predicate computed by conditional statement
-@code{G}. 
+@var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
-Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
-conditional statement @code{G}. 
+Set @var{lhs} to be the @code{LHS} operand of the predicate computed by
+conditional statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
 Return the @code{RHS} operand of the predicate computed by conditional
-@code{G}. 
+@var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
-Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
-conditional statement @code{G}. 
+Set @var{rhs} to be the @code{RHS} operand of the predicate computed by
+conditional statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
-Return the label used by conditional statement @code{G} when its
+Return the label used by conditional statement @var{g} when its
 predicate evaluates to true. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
-Set @code{LABEL} to be the label used by conditional statement @code{G} when
+Set @var{label} to be the label used by conditional statement @var{g} when
 its predicate evaluates to true. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
-Set @code{LABEL} to be the label used by conditional statement @code{G} when
+Set @var{label} to be the label used by conditional statement @var{g} when
 its predicate evaluates to false. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
-Return the label used by conditional statement @code{G} when its
+Return the label used by conditional statement @var{g} when its
 predicate evaluates to false. 
 @end deftypefn
 
@@ -1416,17 +1416,17 @@
 @cindex @code{GIMPLE_EH_FILTER}
 
 @deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
-Build a @code{GIMPLE_EH_FILTER} statement.  @code{TYPES} are the filter's
-types.  @code{FAILURE} is a sequence with the filter's failure action.
+Build a @code{GIMPLE_EH_FILTER} statement.  @var{types} are the filter's
+types.  @var{failure} is a sequence with the filter's failure action.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
-Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}. 
+Return the types handled by @code{GIMPLE_EH_FILTER} statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_eh_filter_types_ptr (gimple g)
 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
-statement @code{G}. 
+statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
@@ -1435,12 +1435,12 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
-Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}. 
+Set @var{types} to be the set of types handled by @code{GIMPLE_EH_FILTER} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
-Set @code{FAILURE} to be the sequence of statements to execute on
-failure for @code{GIMPLE_EH_FILTER} @code{G}. 
+Set @var{failure} to be the sequence of statements to execute on
+failure for @code{GIMPLE_EH_FILTER} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
@@ -1458,29 +1458,29 @@
 
 @deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
-label, @code{LABEL}.
+label, @var{label}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
-Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}. 
+Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
-Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
-statement @code{G}. 
+Set @var{label} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
+statement @var{g}. 
 @end deftypefn
 
 
 @deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
-Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
+Build a @code{GIMPLE_GOTO} statement to label @var{dest}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
-Return the destination of the unconditional jump @code{G}. 
+Return the destination of the unconditional jump @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
-Set @code{DEST} to be the destination of the unconditional jump @code{G}.
+Set @var{dest} to be the destination of the unconditional jump @var{g}.
 @end deftypefn
 
 
@@ -1493,7 +1493,7 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
-Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}. 
+Returns @code{TRUE} if statement @var{g} is a @code{GIMPLE_NOP}.
 @end deftypefn
 
 @node @code{GIMPLE_OMP_ATOMIC_LOAD}
@@ -1501,8 +1501,8 @@
 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
-Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement.  @code{LHS} is the left-hand
-side of the assignment.  @code{RHS} is the right-hand side of the
+Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement.  @var{lhs} is the left-hand
+side of the assignment.  @var{rhs} is the right-hand side of the
 assignment.
 @end deftypefn
 
@@ -1528,7 +1528,7 @@
 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
-Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
+Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @var{val} is the value to be
 stored.
 @end deftypefn
 
@@ -1545,14 +1545,14 @@
 @cindex @code{GIMPLE_OMP_CONTINUE}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
-Build a @code{GIMPLE_OMP_CONTINUE} statement.  @code{CONTROL_DEF} is the
-definition of the control variable.  @code{CONTROL_USE} is the use of
+Build a @code{GIMPLE_OMP_CONTINUE} statement.  @var{control_def} is the
+definition of the control variable.  @var{control_use} is the use of
 the control variable.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
 Return the definition of the control variable on a
-@code{GIMPLE_OMP_CONTINUE} in @code{S}.
+@code{GIMPLE_OMP_CONTINUE} in @var{s}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
@@ -1561,12 +1561,12 @@
  
 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
-statement in @code{S}.
+statement in @var{s}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
-in @code{S}.
+in @var{s}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
@@ -1575,7 +1575,7 @@
  
 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
-in @code{S}.
+in @var{s}.
 @end deftypefn
 
 
@@ -1584,22 +1584,22 @@
 @cindex @code{GIMPLE_OMP_CRITICAL}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
-Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
-statements for which only one thread can execute.  @code{NAME} is an
+Build a @code{GIMPLE_OMP_CRITICAL} statement. @var{body} is the sequence of
+statements for which only one thread can execute.  @var{name} is an
 optional identifier for this critical block.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
-Return the name associated with @code{OMP_CRITICAL} statement @code{G}. 
+Return the name associated with @code{OMP_CRITICAL} statement @var{g}. 
 @end deftypefn
 
 @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}. 
+statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
-Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}. 
+Set @var{name} to be the name associated with @code{OMP} critical statement @var{g}.
 @end deftypefn
 
 @node @code{GIMPLE_OMP_FOR}
@@ -1609,92 +1609,92 @@
 @deftypefn {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 @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
-inside the for loop.  @code{CLAUSES}, are any of the @code{OMP} loop
+Build a @code{GIMPLE_OMP_FOR} statement. @var{body} is sequence of statements
+inside the for loop.  @var{clauses} are any of the @code{OMP} loop
 construct's clauses: private, firstprivate,  lastprivate,
-reductions, ordered, schedule, and nowait.  @code{PRE_BODY} is the
-sequence of statements that are loop invariant.  @code{INDEX} is the
-index variable.  @code{INITIAL} is the initial value of @code{INDEX}.  @code{FINAL} is
-final value of @code{INDEX}.  OMP_FOR_COND is the predicate used to
-compare @code{INDEX} and @code{FINAL}.  @code{INCR} is the increment expression.
+reductions, ordered, schedule, and nowait.  @var{pre_body} is the
+sequence of statements that are loop invariant.  @var{index} is the
+index variable.  @var{initial} is the initial value of @var{index}.  @code{final} is
+final value of @var{index}.  OMP_FOR_COND is the predicate used to
+compare @var{index} and @var{final}.  @var{incr} is the increment expression.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
-Return the clauses associated with @code{OMP_FOR} @code{G}. 
+Return the clauses associated with @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_for_clauses_ptr (gimple g)
-Return a pointer to the @code{OMP_FOR} @code{G}. 
+Return a pointer to the @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}. 
+Set @var{clauses} to be the list of clauses associated with @code{OMP_FOR} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
-Return the index variable for @code{OMP_FOR} @code{G}. 
+Return the index variable for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_for_index_ptr (gimple g)
-Return a pointer to the index variable for @code{OMP_FOR} @code{G}. 
+Return a pointer to the index variable for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
-Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}. 
+Set @var{index} to be the index variable for @code{OMP_FOR} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
-Return the initial value for @code{OMP_FOR} @code{G}. 
+Return the initial value for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_for_initial_ptr (gimple g)
-Return a pointer to the initial value for @code{OMP_FOR} @code{G}. 
+Return a pointer to the initial value for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
-Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
+Set @var{initial} to be the initial value for @code{OMP_FOR} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
-Return the final value for @code{OMP_FOR} @code{G}. 
+Return the final value for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_for_final_ptr (gimple g)
-turn a pointer to the final value for @code{OMP_FOR} @code{G}. 
+turn a pointer to the final value for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
-Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}. 
+Set @var{final} to be the final value for @code{OMP_FOR} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
-Return the increment value for @code{OMP_FOR} @code{G}. 
+Return the increment value for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_for_incr_ptr (gimple g)
-Return a pointer to the increment value for @code{OMP_FOR} @code{G}. 
+Return a pointer to the increment value for @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
-Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}. 
+Set @var{incr} to be the increment value for @code{OMP_FOR} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
 Return the sequence of statements to execute before the @code{OMP_FOR}
-statement @code{G} starts. 
+statement @var{g} starts.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
-Set @code{PRE_BODY} to be the sequence of statements to execute before
-the @code{OMP_FOR} statement @code{G} starts.
+Set @var{pre_body} to be the sequence of statements to execute before
+the @code{OMP_FOR} statement @var{g} starts.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
-Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}. 
+Set @var{cond} to be the condition code for @code{OMP_FOR} @var{g}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} enum tree_code gimple_omp_for_cond (gimple g)
-Return the condition code associated with @code{OMP_FOR} @code{G}. 
+@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
+Return the condition code associated with @code{OMP_FOR} @var{g}. 
 @end deftypefn
 
 
@@ -1703,7 +1703,7 @@
 @cindex @code{GIMPLE_OMP_MASTER}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
-Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
+Build a @code{GIMPLE_OMP_MASTER} statement. @var{body} is the sequence of
 statements to be executed by just the master.
 @end deftypefn
 
@@ -1714,12 +1714,11 @@
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
 Build a @code{GIMPLE_OMP_ORDERED} statement.
-@end deftypefn
 
-@code{BODY} is the sequence of statements inside a loop that will
+@var{body} is the sequence of statements inside a loop that will
 executed in sequence.
+@end deftypefn
 
-
 @node @code{GIMPLE_OMP_PARALLEL}
 @subsection @code{GIMPLE_OMP_PARALLEL}
 @cindex @code{GIMPLE_OMP_PARALLEL}
@@ -1728,67 +1727,67 @@
 Build a @code{GIMPLE_OMP_PARALLEL} statement.
 @end deftypefn
 
-@code{BODY} is sequence of statements which are executed in parallel.
-@code{CLAUSES}, are the @code{OMP} parallel construct's clauses.  @code{CHILD_FN} is
+@var{body} is sequence of statements which are executed in parallel.
+@var{clauses}, are the @code{OMP} parallel construct's clauses.  @var{child_fn} is
 the function created for the parallel threads to execute.
-@code{DATA_ARG} are the shared data argument(s).
+@var{data_arg} are the shared data argument(s).
 
 @deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
-Return true if @code{OMP} parallel statement @code{G} has the
+Return true if @code{OMP} parallel statement @var{g} has the
 @code{GF_OMP_PARALLEL_COMBINED} flag set.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
-@code{G}.
+@var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
-Return the body for the @code{OMP} statement @code{G}. 
+Return the body for the @code{OMP} statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
-Set @code{BODY} to be the body for the @code{OMP} statement @code{G}. 
+Set @var{body} to be the body for the @code{OMP} statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
-Return the clauses associated with @code{OMP_PARALLEL} @code{G}. 
+Return the clauses associated with @code{OMP_PARALLEL} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_parallel_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}. 
+Return a pointer to the clauses associated with @code{OMP_PARALLEL} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the list of clauses associated with
-@code{OMP_PARALLEL} @code{G}. 
+Set @var{clauses} to be the list of clauses associated with
+@code{OMP_PARALLEL} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
 Return the child function used to hold the body of @code{OMP_PARALLEL}
-@code{G}. 
+@var{g}. 
 @end deftypefn
 
 @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}. 
+@code{OMP_PARALLEL} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
-Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}. 
+Set @var{child_fn} to be the child function for @code{OMP_PARALLEL} @var{g}.
 @end deftypefn
 
 @deftypefn {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 @code{OMP_PARALLEL} @code{G}. 
+from the parent to the children threads in @code{OMP_PARALLEL} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_parallel_data_arg_ptr (gimple g)
-Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}. 
+Return a pointer to the data argument for @code{OMP_PARALLEL} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
-Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}. 
+Set @var{data_arg} to be the data argument for @code{OMP_PARALLEL} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt)
@@ -1802,17 +1801,17 @@
 @cindex @code{GIMPLE_OMP_RETURN}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
-Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
+Build a @code{GIMPLE_OMP_RETURN} statement. @var{wait_p} is true if this is a
 non-waiting return.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
-Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
+Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @var{s}.
 @end deftypefn
  
 
 @deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
-Return true if @code{OMP} return statement @code{G} has the
+Return true if @code{OMP} return statement @var{g} has the
 @code{GF_OMP_RETURN_NOWAIT} flag set.
 @end deftypefn
 
@@ -1827,12 +1826,12 @@
 @code{BODY} is the sequence of statements in the section.
 
 @deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
-Return true if @code{OMP} section statement @code{G} has the
+Return true if @code{OMP} section statement @var{g} has the
 @code{GF_OMP_SECTION_LAST} flag set.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
-Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
+Set the @code{GF_OMP_SECTION_LAST} flag on @var{g}.
 @end deftypefn
 
 @node @code{GIMPLE_OMP_SECTIONS}
@@ -1840,8 +1839,8 @@
 @cindex @code{GIMPLE_OMP_SECTIONS}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
-Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
-section statements.  @code{CLAUSES} are any of the @code{OMP} sections
+Build a @code{GIMPLE_OMP_SECTIONS} statement. @var{body} is a sequence of
+section statements.  @var{clauses} are any of the @code{OMP} sections
 construct's clauses: private, firstprivate, lastprivate,
 reduction, and nowait.
 @end deftypefn
@@ -1853,30 +1852,30 @@
 
 @deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
 Return the control variable associated with the
-@code{GIMPLE_OMP_SECTIONS} in @code{G}.
+@code{GIMPLE_OMP_SECTIONS} in @var{g}.
 @end deftypefn
  
 @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}.
+@code{GIMPLE_OMP_SECTIONS} in @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
-Set @code{CONTROL} to be the set of clauses associated with the
-@code{GIMPLE_OMP_SECTIONS} in @code{G}.
+Set @var{control} to be the set of clauses associated with the
+@code{GIMPLE_OMP_SECTIONS} in @var{g}.
 @end deftypefn
  
 @deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
-Return the clauses associated with @code{OMP_SECTIONS} @code{G}. 
+Return the clauses associated with @code{OMP_SECTIONS} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_sections_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}. 
+Return a pointer to the clauses associated with @code{OMP_SECTIONS} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
-@code{G}. 
+Set @var{clauses} to be the set of clauses associated with @code{OMP_SECTIONS}
+@var{g}.
 @end deftypefn
 
 
@@ -1885,22 +1884,22 @@
 @cindex @code{GIMPLE_OMP_SINGLE}
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
-Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
-statements that will be executed once.  @code{CLAUSES} are any of the
+Build a @code{GIMPLE_OMP_SINGLE} statement. @var{body} is the sequence of
+statements that will be executed once.  @var{clauses} are any of the
 @code{OMP} single construct's clauses: private, firstprivate,
 copyprivate, nowait.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
-Return the clauses associated with @code{OMP_SINGLE} @code{G}. 
+Return the clauses associated with @code{OMP_SINGLE} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_omp_single_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}. 
+Return a pointer to the clauses associated with @code{OMP_SINGLE} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}. 
+Set @var{clauses} to be the clauses associated with @code{OMP_SINGLE} @var{g}.
 @end deftypefn
 
 
@@ -1913,35 +1912,35 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
-Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}. 
+Return the maximum number of arguments supported by @code{GIMPLE_PHI} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
-Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
+Return the number of arguments in @code{GIMPLE_PHI} @var{g}. This must always
 be exactly the number of incoming edges for the basic block
-holding @code{G}. 
+holding @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
-Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 
+Return the @code{SSA} name created by @code{GIMPLE_PHI} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree *gimple_phi_result_ptr (gimple g)
-Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 
+Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
-Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 
+Set @var{result} to be the @code{SSA} name created by @code{GIMPLE_PHI} @var{g}.
 @end deftypefn
 
-@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}. 
+@deftypefn {GIMPLE function} {struct phi_arg_d} *gimple_phi_arg (gimple g, unsigned index)
+Return the @code{PHI} argument corresponding to incoming edge @var{index} for
+@code{GIMPLE_PHI} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
-Set @code{PHIARG} to be the argument corresponding to incoming edge
-@code{INDEX} for @code{GIMPLE_PHI} @code{G}. 
+Set @var{phiarg} to be the argument corresponding to incoming edge
+@var{index} for @code{GIMPLE_PHI} @var{g}.
 @end deftypefn
 
 @node @code{GIMPLE_RESX}
@@ -1951,16 +1950,16 @@
 @deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
 Build a @code{GIMPLE_RESX} statement which is a statement.  This
 statement is a placeholder for _Unwind_Resume before we know if a
-function call or a branch is needed.  @code{REGION} is the exception
+function call or a branch is needed.  @var{region} is the exception
 region from which control is flowing.
 @end deftypefn
 
 @deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
-Return the region number for @code{GIMPLE_RESX} @code{G}. 
+Return the region number for @code{GIMPLE_RESX} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
-Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}. 
+Set @var{region} to be the region number for @code{GIMPLE_RESX} @var{g}.
 @end deftypefn
 
 @node @code{GIMPLE_RETURN}
@@ -1968,15 +1967,15 @@
 @cindex @code{GIMPLE_RETURN}
 
 @deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
-Build a @code{GIMPLE_RETURN} statement whose return value is retval.
+Build a @code{GIMPLE_RETURN} statement whose return value is @var{retval}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
-Return the return value for @code{GIMPLE_RETURN} @code{G}. 
+Return the return value for @code{GIMPLE_RETURN} @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
-Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}. 
+Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @var{g}. 
 @end deftypefn
 
 @node @code{GIMPLE_SWITCH}
@@ -1984,45 +1983,45 @@
 @cindex @code{GIMPLE_SWITCH}
 
 @deftypefn {GIMPLE function} gimple gimple_build_switch ( nlabels, tree index, tree default_label, ...)
-Build a @code{GIMPLE_SWITCH} statement.  @code{NLABELS} are the number of
+Build a @code{GIMPLE_SWITCH} statement.  @var{nlabels} is the number of
 labels excluding the default label.  The default label is passed
-in @code{DEFAULT_LABEL}.  The rest of the arguments are trees
+in @var{default_label}.  The rest of the arguments are trees
 representing the labels.  Each label is a tree of code
 @code{CASE_LABEL_EXPR}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree default_label, @code{VEC}(tree,heap) *args)
 This function is an alternate way of building @code{GIMPLE_SWITCH}
-statements.  @code{INDEX} and @code{DEFAULT_LABEL} are as in
-gimple_build_switch.  @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees
+statements.  @var{index} and @var{default_label} are as in
+gimple_build_switch.  @var{args} is a vector of @code{CASE_LABEL_EXPR} trees
 that contain the labels.
 @end deftypefn
 
 @deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
 Return the number of labels associated with the switch statement
-@code{G}. 
+@var{g}.
 @end deftypefn
 
 @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}. 
+Set @var{nlabels} to be the number of labels for the switch statement
+@var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
-Return the index variable used by the switch statement @code{G}. 
+Return the index variable used by the switch statement @var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
-Set @code{INDEX} to be the index variable for switch statement @code{G}. 
+Set @var{index} to be the index variable for switch statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
-Return the label numbered @code{INDEX}. The default label is 0, followed
+Return the label numbered @var{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)
-Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
+Set the label number @var{index} to @var{label}. 0 is always the default
 label. 
 @end deftypefn
 
@@ -2040,16 +2039,16 @@
 @cindex @code{GIMPLE_TRY}
 
 @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
+Build a @code{GIMPLE_TRY} statement.  @var{eval} is a sequence with the
+expression to evaluate.  @var{cleanup} is a sequence of statements to
+run at clean-up time.  @var{kind} is the enumeration value
 @code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
 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)
-Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
+@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
+Return the kind of try block represented by @code{GIMPLE_TRY} @var{g}. This is
 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}. 
 @end deftypefn
 
@@ -2059,12 +2058,12 @@
 
 @deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
-@code{G}. 
+@var{g}. 
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
 Return the sequence of statements used as the cleanup body for
-@code{GIMPLE_TRY} @code{G}. 
+@code{GIMPLE_TRY} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
@@ -2072,13 +2071,13 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
-Set @code{EVAL} to be the sequence of statements to use as the body for
-@code{GIMPLE_TRY} @code{G}. 
+Set @var{eval} to be the sequence of statements to use as the body for
+@code{GIMPLE_TRY} @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
-Set @code{CLEANUP} to be the sequence of statements to use as the
-cleanup body for @code{GIMPLE_TRY} @code{G}. 
+Set @var{cleanup} to be the sequence of statements to use as the
+cleanup body for @code{GIMPLE_TRY} @var{g}.
 @end deftypefn
 
 @node @code{GIMPLE_WITH_CLEANUP_EXPR}
@@ -2086,24 +2085,24 @@
 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
 
 @deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
-Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @code{CLEANUP} is the
+Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @var{cleanup} is the
 clean-up expression.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
-Return the cleanup sequence for cleanup statement @code{G}. 
+Return the cleanup sequence for cleanup statement @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
-Set @code{CLEANUP} to be the cleanup sequence for @code{G}. 
+Set @var{cleanup} to be the cleanup sequence for @var{g}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
-Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple. 
+Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
-Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple. 
+Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
 @end deftypefn
 
 
@@ -2130,13 +2129,13 @@
 Below is a list of functions to manipulate and query sequences.
 
 @deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
-Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
-not @code{NULL}.  If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
+Link a gimple statement to the end of the sequence *@var{seq} if @var{g} is
+not @code{NULL}.  If *@var{seq} is @code{NULL}, allocate a sequence before linking.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
-Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
-@code{NULL}.  If *@code{DEST} is @code{NULL}, allocate a new sequence before
+Append sequence @var{src} to the end of sequence *@var{dest} if @var{src} is not
+@code{NULL}.  If *@var{dest} is @code{NULL}, allocate a new sequence before
 appending.
 @end deftypefn
 
@@ -2145,28 +2144,28 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
-Reverse the order of the statements in the sequence @code{SEQ}.  Return
-@code{SEQ}.
+Reverse the order of the statements in the sequence @var{seq}.  Return
+@var{seq}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
-Return the first statement in sequence @code{S}.
+Return the first statement in sequence @var{s}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
-Return the last statement in sequence @code{S}.
+Return the last statement in sequence @var{s}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
-Set the last statement in sequence @code{S} to the statement in @code{LAST}.
+Set the last statement in sequence @var{s} to the statement in @var{last}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
-Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
+Set the first statement in sequence @var{s} to the statement in @var{first}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
-Initialize sequence @code{S} to an empty sequence.
+Initialize sequence @var{s} to an empty sequence.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
@@ -2175,23 +2174,23 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
-Copy the sequence @code{SRC} into the sequence @code{DEST}.
+Copy the sequence @var{src} into the sequence @var{dest}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
-Return true if the sequence @code{S} is empty.
+Return true if the sequence @var{s} is empty.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
-Returns the sequence of statements in @code{BB}.
+Returns the sequence of statements in @var{bb}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
-Sets the sequence of statements in @code{BB} to @code{SEQ}.
+Sets the sequence of statements in @var{bb} to @var{seq}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
-Determine whether @code{SEQ} contains exactly one statement.
+Determine whether @var{seq} contains exactly one statement.
 @end deftypefn
 
 @node Sequence iterators 
@@ -2199,7 +2198,7 @@
 @cindex Sequence iterators 
 
 Sequence iterators are convenience constructs for iterating
-through statements in a sequence.  Given a sequence @code{SEQ}, here is
+through statements in a sequence.  Given a sequence @var{seq}, here is
 a typical use of gimple sequence iterators:
 
 @smallexample
@@ -2208,7 +2207,7 @@
 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
   @{
     gimple g = gsi_stmt (gsi);
-    /* Do something with gimple statement @code{G}.  */
+    /* Do something with gimple statement @var{g}.  */
   @}
 @end smallexample
 
@@ -2240,35 +2239,35 @@
 statement iterators.
 
 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
-Return a new iterator pointing to the sequence @code{SEQ}'s first
-statement.  If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
+Return a new iterator pointing to the sequence @var{seq}'s first
+statement.  If @var{seq} is empty, the iterator's basic block is @code{NULL}.
 Use @code{gsi_start_bb} instead when the iterator needs to always have
 the correct basic block set.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
 Return a new iterator pointing to the first statement in basic
-block @code{BB}.
+block @var{bb}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
 Return a new iterator initially pointing to the last statement of
-sequence @code{SEQ}.  If @code{SEQ} is empty, the iterator's basic block is
+sequence @var{seq}.  If @var{seq} is empty, the iterator's basic block is
 @code{NULL}.  Use @code{gsi_last_bb} instead when the iterator needs to always
 have the correct basic block set.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
 Return a new iterator pointing to the last statement in basic
-block @code{BB}.
+block @var{bb}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
-Return @code{TRUE} if at the end of @code{I}.
+Return @code{TRUE} if at the end of @var{i}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
-Return @code{TRUE} if we're one statement before the end of @code{I}.
+Return @code{TRUE} if we're one statement before the end of @var{i}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
@@ -2285,7 +2284,7 @@
 
 @deftypefn {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 @code{BB}.
+non-label statement in block @var{bb}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple *gsi_stmt_ptr (gimple_stmt_iterator *i)
@@ -2302,98 +2301,98 @@
 
 @deftypefn {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 @code{REMOVE_EH_INFO} is
-true we remove the statement pointed to by iterator @code{I} from the @code{EH}
+updated to point to the next statement.  When @var{remove_eh_info} is
+true we remove the statement pointed to by iterator @var{i} from the @code{EH}
 tables.  Otherwise we do not modify the @code{EH} tables.  Generally,
 @code{REMOVE_EH_INFO} should be true when the statement is going to be
 removed from the @code{IL} and not reinserted elsewhere.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
-Links the sequence of statements @code{SEQ} before the statement pointed
-by iterator @code{I}.  @code{MODE} indicates what to do with the iterator
+Links the sequence of statements @var{seq} before the statement pointed
+by iterator @var{i}.  @var{mode} indicates what to do with the iterator
 after insertion (see @code{enum gsi_iterator_update} above).
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
-Links statement @code{G} before the statement pointed-to by iterator @code{I}.
-Updates iterator @code{I} according to @code{MODE}.
+Links statement @var{g} before the statement pointed-to by iterator @var{i}.
+Updates iterator @var{i} according to @var{mode}.
 @end deftypefn
 
 @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}.
+Links sequence @var{seq} after the statement pointed-to by iterator @var{i}.
+@var{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)
-Links statement @code{G} after the statement pointed-to by iterator @code{I}.
-@code{MODE} is as in @code{gsi_insert_after}.
+Links statement @var{g} after the statement pointed-to by iterator @var{i}.
+@var{mode} is as in @code{gsi_insert_after}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
-Move all statements in the sequence after @code{I} to a new sequence.
+Move all statements in the sequence after @var{i} to a new sequence.
 Return this new sequence.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
-Move all statements in the sequence before @code{I} to a new sequence.
+Move all statements in the sequence before @var{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)
-Replace the statement pointed-to by @code{I} to @code{STMT}.  If @code{UPDATE_EH_INFO}
+Replace the statement pointed-to by @var{i} to @var{stmt}.  If @var{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)
-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
+Insert statement @var{stmt} before the statement pointed-to by iterator
+@var{i}, update @var{stmt}'s basic block and scan it for new operands.  @var{mode}
+specifies how to update iterator @var{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)
-Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
+Like @code{gsi_insert_before}, but for all the statements in @var{seq}.
 @end deftypefn
 
 @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
+Insert statement @var{stmt} after the statement pointed-to by iterator
+@var{i}, update @var{stmt}'s basic block and scan it for new operands.  @var{mode}
+specifies how to update iterator @var{o} 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)
-Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
+Like @code{gsi_insert_after}, but for all the statements in @var{seq}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
-Finds iterator for @code{STMT}.
+Finds iterator for @var{stmt}.
 @end deftypefn
 
 @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}.
+Move the statement at @var{from} so it comes right after the statement
+at @var{to}.
 @end deftypefn
 
 @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}.
+Move the statement at @var{from} so it comes right before the statement
+at @var{to}.
 @end deftypefn
 
 @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}.
+Move the statement at @var{from} to the end of basic block @var{bb}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
-Add @code{STMT} to the pending list of edge @code{E}.  No actual insertion is
+Add @var{stmt} to the pending list of edge @var{e}.  No actual insertion is
 made until a call to @code{gsi_commit_edge_inserts}() is made.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
-Add the sequence of statements in @code{SEQ} to the pending list of edge
-@code{E}.  No actual insertion is made until a call to
+Add the sequence of statements in @var{seq} to the pending list of edge
+@var{e}.  No actual insertion is made until a call to
 @code{gsi_commit_edge_inserts}() is made.
 @end deftypefn
 
@@ -2403,8 +2402,8 @@
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
-Commit insertions pending at edge @code{E}.  If a new block is created,
-set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
+Commit insertions pending at edge @var{e}.  If a new block is created,
+set @var{new_bb} to this block, otherwise set it to @code{NULL}.
 @end deftypefn
 
 @deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
@@ -2451,48 +2450,48 @@
 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)
-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
+This function is used to walk the current statement in @var{gsi},
+optionally using traversal state stored in @var{wi}.  If @var{wi} is @code{NULL}, no
 state is kept during the traversal.
 
-The callback @code{CALLBACK_STMT} is called.  If @code{CALLBACK_STMT} returns
+The callback @var{callback_stmt} is called.  If @var{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 @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
+If @var{callback_stmt} is @code{NULL} or it returns false, @var{callback_op} is
 called on each operand of the statement via @code{walk_gimple_op}.  If
 @code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
 operands are not scanned.
 
 The return value is that returned by the last call to
-@code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
+@code{walk_gimple_op}, or @code{NULL_TREE} if no @var{callback_op} is specified.
 @end deftypefn
 
 
 @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
+Use this function to walk the operands of statement @var{stmt}.  Every
 operand is walked via @code{walk_tree} with optional state information
-in @code{WI}.
+in @var{wi}.
 
-@code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
-Additional parameters to @code{walk_tree} must be stored in @code{WI}.  For
+@var{callback_op} is called on each operand of @var{stmt} via @code{walk_tree}.
+Additional parameters to @code{walk_tree} must be stored in @var{wi}.  For
 each operand @code{OP}, @code{walk_tree} is called as:
 
 @smallexample
-    walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{WI}- @code{PSET})
+    walk_tree (&@code{OP}, @var{callback_op}, @var{wi}, @var{wi}- @code{PSET})
 @end smallexample
 
-If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
+If @var{callback_op} returns non-@code{NULL} for an operand, the remaining
 operands are not scanned.  The return value is that returned by
-the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
+the last call to @code{walk_tree}, or @code{NULL_TREE} if no @var{callback_op} is
 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)
-This function walks all the statements in the sequence @code{SEQ}
-calling @code{walk_gimple_stmt} on each one.  @code{WI} is as in
+This function walks all the statements in the sequence @var{seq}
+calling @code{walk_gimple_stmt} on each one.  @var{wi} is as in
 @code{walk_gimple_stmt}.  If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
 is stopped and the value returned.  Otherwise, all the statements
 are walked and @code{NULL_TREE} returned.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]