Lines Matching refs:code
15 choices. For one thing, SIMPLE doesn't support @code{goto}.
37 @code{DECL_SAVED_TREE} field of the associated @code{FUNCTION_DECL}
39 @code{gimplify_function_tree}.
43 definition of @code{LANG_HOOKS_GIMPLIFY_EXPR} which knows how to
45 much of the same code for expanding front end trees to RTL@. This function
49 consists of the IL before the pass @code{pass_lower_cf}. High GIMPLE
51 (represented by @code{GIMPLE_BIND}) and nested expressions (e.g.,
52 @code{GIMPLE_TRY}), while ``Low GIMPLE'' exposes all of the
59 @code{_STMT} nodes and how to convert them to GENERIC forms. There
61 the existence of @code{STMT_EXPR} meant that in order to convert all
82 * Adding a new GIMPLE statement code::
95 @subsection @code{gimple} (gsbase)
105 @multitable {@code{references_memory_p}} {Size (bits)}
107 @item @code{code} @tab 8
108 @item @code{subcode} @tab 16
109 @item @code{no_warning} @tab 1
110 @item @code{visited} @tab 1
111 @item @code{nontemporal_move} @tab 1
112 @item @code{plf} @tab 2
113 @item @code{modified} @tab 1
114 @item @code{has_volatile_ops} @tab 1
115 @item @code{references_memory_p} @tab 1
116 @item @code{uid} @tab 32
117 @item @code{location} @tab 32
118 @item @code{num_ops} @tab 32
119 @item @code{bb} @tab 64
120 @item @code{block} @tab 63
125 @item @code{code}
128 @item @code{subcode}
130 instruction or provide flags applicable to a given code. The
131 @code{subcode} flags field has different uses depending on the code of
136 @code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
138 @item @code{no_warning}
142 @item @code{visited}
146 @item @code{nontemporal_move}
152 @item @code{plf}
157 @item @code{modified}
162 @item @code{has_volatile_ops}
166 @item @code{references_memory_p}
171 @item @code{uid}
176 @item @code{location}
177 This is a @code{location_t} identifier to specify source code
181 @item @code{num_ops}
187 @item @code{bb}
190 @item @code{block}
195 @subsection @code{gimple_statement_with_ops}
199 @code{gimple_statement_with_ops_base} and
200 @code{gimple_statement_with_ops}. This is needed to accommodate the
203 number of operands, the memory allocator (@code{gimple_alloc}) simply
204 allocates enough memory to hold the structure itself plus @code{N
207 @code{gimple_alloc} reserves @code{sizeof (struct
211 with the @code{gimple_statement_with_memory_ops} tuple. So, these
212 common fields are placed in @code{gimple_statement_with_ops_base} which
216 @multitable {@code{def_ops}} {48 + 8 * @code{num_ops} bytes}
217 @item @code{gsbase} @tab 256
218 @item @code{def_ops} @tab 64
219 @item @code{use_ops} @tab 64
220 @item @code{op} @tab @code{num_ops} * 64
221 @item Total size @tab 48 + 8 * @code{num_ops} bytes
225 @item @code{gsbase}
226 Inherited from @code{struct gimple}.
228 @item @code{def_ops}
235 @item @code{use_ops}
236 Similar to @code{def_ops} but for variables read by the statement.
238 @item @code{op}
239 Array of trees with @code{num_ops} slots.
242 @subsection @code{gimple_statement_with_memory_ops}
244 This tuple is essentially identical to @code{gimple_statement_with_ops},
248 vector (@code{gimple_statement_with_memory_ops_base} and
249 @code{gimple_statement_with_memory_ops}).
252 @multitable {@code{vdef_ops}} {80 + 8 * @code{num_ops} bytes}
254 @item @code{gsbase} @tab 256
255 @item @code{def_ops} @tab 64
256 @item @code{use_ops} @tab 64
257 @item @code{vdef_ops} @tab 64
258 @item @code{vuse_ops} @tab 64
259 @item @code{stores} @tab 64
260 @item @code{loads} @tab 64
261 @item @code{op} @tab @code{num_ops} * 64
262 @item Total size @tab 80 + 8 * @code{num_ops} bytes
266 @item @code{vdef_ops}
267 Similar to @code{def_ops} but for @code{VDEF} operators. There is
271 @item @code{vuse_ops}
272 Similar to @code{use_ops} but for @code{VUSE} operators. There is
276 @item @code{stores}
278 statement. This is different than @code{vdef_ops} in that all the
280 partitioning is enabled, the @code{vdef_ops} vector will refer to memory
284 @item @code{loads}
285 Similar to @code{stores}, but for memory loads. (Note that there
299 kinds, along with their relationships to @code{GSS_} values (layouts) and
300 @code{GIMPLE_} values (codes):
317 | | | code: GIMPLE_COND
320 | | | code: GIMPLE_DEBUG
323 | | | code: GIMPLE_GOTO
326 | | | code: GIMPLE_LABEL
329 | | code: GIMPLE_SWITCH
338 | | | code GIMPLE_ASSIGN
341 | | code GIMPLE_RETURN
344 | | layout: GSS_CALL, code: GIMPLE_CALL
347 | | layout: GSS_ASM, code: GIMPLE_ASM
350 | layout: GSS_TRANSACTION, code: GIMPLE_TRANSACTION
353 | | layout: GSS_OMP. Used for code GIMPLE_OMP_SECTION
356 | | layout: GSS_OMP_CRITICAL, code: GIMPLE_OMP_CRITICAL
359 | | layout: GSS_OMP_FOR, code: GIMPLE_OMP_FOR
367 | | | | code: GIMPLE_OMP_PARALLEL
370 | | | code: GIMPLE_OMP_TASK
373 | | code: GIMPLE_OMP_TARGET
376 | | layout: GSS_OMP_SECTIONS, code: GIMPLE_OMP_SECTIONS
382 | | code: GIMPLE_OMP_SINGLE
385 | code: GIMPLE_OMP_TEAMS
388 | layout: GSS_BIND, code: GIMPLE_BIND
391 | layout: GSS_CATCH, code: GIMPLE_CATCH
394 | layout: GSS_EH_FILTER, code: GIMPLE_EH_FILTER
397 | layout: GSS_EH_ELSE, code: GIMPLE_EH_ELSE
400 | layout: GSS_EH_MNT, code: GIMPLE_EH_MUST_NOT_THROW
403 | layout: GSS_PHI, code: GIMPLE_PHI
409 | | code: GIMPLE_RESX
412 | code: GIMPLE_EH_DISPATCH
415 | layout: GSS_TRY, code: GIMPLE_TRY
418 | layout: GSS_WCE, code: GIMPLE_WITH_CLEANUP_EXPR
421 | layout: GSS_OMP_CONTINUE, code: GIMPLE_OMP_CONTINUE
424 | layout: GSS_OMP_ATOMIC_LOAD, code: GIMPLE_OMP_ATOMIC_LOAD
428 | code: GIMPLE_OMP_ATOMIC_STORE
431 | code: GIMPLE_OMP_ATOMIC_STORE
434 code: GIMPLE_OMP_RETURN
444 @multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE}
446 @item @code{GIMPLE_ASM} @tab x @tab x
447 @item @code{GIMPLE_ASSIGN} @tab x @tab x
448 @item @code{GIMPLE_BIND} @tab x @tab
449 @item @code{GIMPLE_CALL} @tab x @tab x
450 @item @code{GIMPLE_CATCH} @tab x @tab
451 @item @code{GIMPLE_COND} @tab x @tab x
452 @item @code{GIMPLE_DEBUG} @tab x @tab x
453 @item @code{GIMPLE_EH_FILTER} @tab x @tab
454 @item @code{GIMPLE_GOTO} @tab x @tab x
455 @item @code{GIMPLE_LABEL} @tab x @tab x
456 @item @code{GIMPLE_NOP} @tab x @tab x
457 @item @code{GIMPLE_OMP_ATOMIC_LOAD} @tab x @tab x
458 @item @code{GIMPLE_OMP_ATOMIC_STORE} @tab x @tab x
459 @item @code{GIMPLE_OMP_CONTINUE} @tab x @tab x
460 @item @code{GIMPLE_OMP_CRITICAL} @tab x @tab x
461 @item @code{GIMPLE_OMP_FOR} @tab x @tab x
462 @item @code{GIMPLE_OMP_MASTER} @tab x @tab x
463 @item @code{GIMPLE_OMP_ORDERED} @tab x @tab x
464 @item @code{GIMPLE_OMP_PARALLEL} @tab x @tab x
465 @item @code{GIMPLE_OMP_RETURN} @tab x @tab x
466 @item @code{GIMPLE_OMP_SECTION} @tab x @tab x
467 @item @code{GIMPLE_OMP_SECTIONS} @tab x @tab x
468 @item @code{GIMPLE_OMP_SECTIONS_SWITCH} @tab x @tab x
469 @item @code{GIMPLE_OMP_SINGLE} @tab x @tab x
470 @item @code{GIMPLE_PHI} @tab @tab x
471 @item @code{GIMPLE_RESX} @tab @tab x
472 @item @code{GIMPLE_RETURN} @tab x @tab x
473 @item @code{GIMPLE_SWITCH} @tab x @tab x
474 @item @code{GIMPLE_TRY} @tab x @tab
482 @code{GIMPLE_TRY_CATCH}. @code{GIMPLE_TRY_CATCH} has two operands. The
486 operand of the @code{GIMPLE_TRY_CATCH} is checked. The second
494 @item A sequence of @code{GIMPLE_CATCH} statements. Each
495 @code{GIMPLE_CATCH} has a list of applicable exception types and
496 handler code. If the thrown exception matches one of the caught
497 types, the associated handler code is executed. If the handler
498 code falls off the bottom, execution continues after the original
499 @code{GIMPLE_TRY_CATCH}.
501 @item A @code{GIMPLE_EH_FILTER} statement. This has a list of
502 permitted exception types, and code to handle a match failure. If the
504 associated match failure code is executed. If the thrown exception
518 cleanup is represented with a @code{GIMPLE_RESX}.
530 @code{get_formal_tmp_var}. The compiler tries to always evaluate
538 using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
540 Currently, an expression like @code{a = b + 5} is not reduced any
558 GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
570 The same rule holds for arguments to a @code{GIMPLE_CALL}.
573 @code{MEM_REF} or a compound lvalue as described below.
594 are not broken down; an expression like @code{a.b[2] = 42} is not reduced
604 alias analysis would not remember that the reference to @code{T1[2]} came
605 by way of @code{a.b}, so it would think that the assignment could alias
606 another member of @code{a}; this broke @code{struct-alias-1.c}. Future
613 A C @code{?:} expression is converted into an @code{if} statement with
628 The GIMPLE level if-conversion pass re-introduces @code{?:}
632 Note that in GIMPLE, @code{if} statements are represented using
633 @code{GIMPLE_COND}, as described below.
640 @code{GIMPLE_COND}, logical `and' and `or' operators are simplified
641 as follows: @code{a = b && c} becomes
650 Note that @code{T1} in this example cannot be an expression temporary,
655 All gimple operands are of type @code{tree}. But only certain
658 @code{get_gimple_rhs_class}, which given a tree code, returns an
659 @code{enum} with the following values of type @code{enum
663 @item @code{GIMPLE_INVALID_RHS}
666 @item @code{GIMPLE_TERNARY_RHS}
669 @item @code{GIMPLE_BINARY_RHS}
672 @item @code{GIMPLE_UNARY_RHS}
675 @item @code{GIMPLE_SINGLE_RHS}
677 operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc).
681 more than two slots on the RHS. For instance, a @code{COND_EXPR}
682 expression of the form @code{(a op b) ? x : y} could be flattened
684 require additional processing to distinguish @code{c = a op b}
685 from @code{c = a op b ? x : y}. Something similar occurs with
686 @code{ASSERT_EXPR}. In time, these special case tree
690 For tree nodes in the categories @code{GIMPLE_TERNARY_RHS},
691 @code{GIMPLE_BINARY_RHS} and @code{GIMPLE_UNARY_RHS}, they cannot be
707 identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
709 instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree
720 the code of a given statement, its operand vector will be at
729 Returns operand @code{I} from statement @code{G}.
733 Returns a pointer into the operand vector for statement @code{G}. This
734 is computed using an internal table called @code{gimple_ops_offset_}[].
735 This table is indexed by the gimple code of @code{G}.
738 sizes of the structures used by each statement code defined in
740 structure, for a gimple code @code{C} the offset is computed as sizeof
741 (struct-of @code{C}) - sizeof (tree).
744 using @code{gimple_op}(), if this becomes a bottleneck, a pass can
745 choose to memoize the result from @code{gimple_ops}() and use that to
754 @code{gimple_@var{name}_set_...()}. Each tuple will use one of the
760 @code{is_gimple_reg} returns true) and constants (expressions for which
761 @code{is_gimple_min_invariant} returns true).
770 Similar to @code{is_gimple_val} but it also accepts hard registers.
775 called by a @code{GIMPLE_CALL}.
780 of a @code{MEM_REF} expression.
801 Return true if t is an @code{ADDR_EXPR} that does not change once the
809 Return true if the code of g is @code{GIMPLE_ASSIGN}.
813 Return true if the code of g is @code{GIMPLE_CALL}.
817 Return true if the code of g is @code{GIMPLE_DEBUG}.
821 Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
826 Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
835 Return true if g is a @code{GIMPLE_DEBUG} that marks the beginning of
840 Return true if g is a @code{GIMPLE_DEBUG} that marks the entry
845 Return true if g is a @code{GIMPLE_DEBUG} that marks a program location,
860 Return the code for statement @code{G}.
864 Return the basic block to which statement @code{G} belongs to.
868 Return the lexical scope block holding statement @code{G}.
872 Return the type of the main expression computed by @code{STMT}. Return
873 @code{void_type_node} if @code{STMT} computes nothing. This will only return
874 something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
875 @code{GIMPLE_CALL}. For all other tuple codes, it will return
876 @code{void_type_node}.
880 Return the tree code for the expression computed by @code{STMT}. This
881 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
882 @code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
883 For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
884 For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
885 by the @code{RHS} of the assignment.
889 Set the lexical scope block of @code{G} to @code{BLOCK}.
893 Return locus information for statement @code{G}.
897 Set locus information for statement @code{G}.
901 Return true if @code{G} does not have locus information.
905 Return true if no warnings should be emitted for statement @code{STMT}.
909 Set the visited status on statement @code{STMT} to @code{VISITED_P}.
913 Return the visited status on statement @code{STMT}.
917 Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
921 Return the value of pass local flag @code{PLF} on statement @code{STMT}.
925 Return true if statement @code{G} has register or memory operands.
929 Return true if statement @code{G} has memory operands.
933 Return the number of operands for statement @code{G}.
937 Return the array of operands for statement @code{G}.
941 Return operand @code{I} for statement @code{G}.
945 Return a pointer to operand @code{I} for statement @code{G}.
949 Set operand @code{I} of statement @code{G} to @code{OP}.
954 @code{STMT}.
958 Return the set of @code{DEF} operands for statement @code{G}.
962 Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
966 Return the set of @code{USE} operands for statement @code{G}.
970 Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
974 Return the set of @code{VUSE} operands for statement @code{G}.
978 Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
982 Return the set of @code{VDEF} operands for statement @code{G}.
986 Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
990 Return the set of symbols loaded by statement @code{G}. Each element of
991 the set is the @code{DECL_UID} of the corresponding symbol.
995 Return the set of symbols stored by statement @code{G}. Each element of
996 the set is the @code{DECL_UID} of the corresponding symbol.
1000 Return true if statement @code{G} has operands and the modified field
1005 Return true if statement @code{STMT} contains volatile operands.
1009 Return true if statement @code{STMT} contains volatile operands.
1013 Mark statement @code{S} as modified, and update it.
1017 Update statement @code{S} if it has been marked modified.
1021 Return a deep copy of statement @code{STMT}.
1029 * @code{GIMPLE_ASM}::
1030 * @code{GIMPLE_ASSIGN}::
1031 * @code{GIMPLE_BIND}::
1032 * @code{GIMPLE_CALL}::
1033 * @code{GIMPLE_CATCH}::
1034 * @code{GIMPLE_COND}::
1035 * @code{GIMPLE_DEBUG}::
1036 * @code{GIMPLE_EH_FILTER}::
1037 * @code{GIMPLE_LABEL}::
1038 * @code{GIMPLE_GOTO}::
1039 * @code{GIMPLE_NOP}::
1040 * @code{GIMPLE_OMP_ATOMIC_LOAD}::
1041 * @code{GIMPLE_OMP_ATOMIC_STORE}::
1042 * @code{GIMPLE_OMP_CONTINUE}::
1043 * @code{GIMPLE_OMP_CRITICAL}::
1044 * @code{GIMPLE_OMP_FOR}::
1045 * @code{GIMPLE_OMP_MASTER}::
1046 * @code{GIMPLE_OMP_ORDERED}::
1047 * @code{GIMPLE_OMP_PARALLEL}::
1048 * @code{GIMPLE_OMP_RETURN}::
1049 * @code{GIMPLE_OMP_SECTION}::
1050 * @code{GIMPLE_OMP_SECTIONS}::
1051 * @code{GIMPLE_OMP_SINGLE}::
1052 * @code{GIMPLE_PHI}::
1053 * @code{GIMPLE_RESX}::
1054 * @code{GIMPLE_RETURN}::
1055 * @code{GIMPLE_SWITCH}::
1056 * @code{GIMPLE_TRY}::
1057 * @code{GIMPLE_WITH_CLEANUP_EXPR}::
1061 @node @code{GIMPLE_ASM}
1062 @subsection @code{GIMPLE_ASM}
1063 @cindex @code{GIMPLE_ASM}
1069 Build a @code{GIMPLE_ASM} statement. This statement is used for
1070 building in-line assembly constructs. @code{STRING} is the assembly
1071 code. @code{INPUTS}, @code{OUTPUTS}, @code{CLOBBERS} and @code{LABELS}
1076 Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
1080 Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
1084 Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
1089 Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1094 Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1099 Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1104 Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1109 Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1114 Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1119 @code{GIMPLE_ASM} @code{G}.
1123 Return true if @code{G} is an asm statement marked volatile.
1128 Mark asm statement @code{G} as volatile or non-volatile based on
1129 @code{VOLATILE_P}.
1132 @node @code{GIMPLE_ASSIGN}
1133 @subsection @code{GIMPLE_ASSIGN}
1134 @cindex @code{GIMPLE_ASSIGN}
1137 Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue
1146 @code{gimple_build_assign} with @code{enum tree_code} argument and separate
1152 This function is similar to two operand @code{gimple_build_assign},
1153 but is used to build a @code{GIMPLE_ASSIGN} statement when the operands of the
1158 @code{tree_code} for the right-hand side of the assignment. Op1, op2 and op3
1164 Like the above 5 operand @code{gimple_build_assign}, but with the last
1165 argument @code{NULL} - this overload should not be used for
1166 @code{GIMPLE_TERNARY_RHS} assignments.
1171 Like the above 4 operand @code{gimple_build_assign}, but with the last
1172 argument @code{NULL} - this overload should be used only for
1173 @code{GIMPLE_UNARY_RHS} and @code{GIMPLE_SINGLE_RHS} assignments.
1177 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
1178 @code{*SEQ_P}.
1181 @code{DST}/@code{SRC} are the destination and source respectively. You can
1182 pass ungimplified trees in @code{DST} or @code{SRC}, in which
1185 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
1188 Return the code of the expression computed on the @code{RHS} of
1189 assignment statement @code{G}.
1194 Return the gimple rhs class of the code for the expression
1195 computed on the rhs of assignment statement @code{G}. This will never
1196 return @code{GIMPLE_INVALID_RHS}.
1200 Return the @code{LHS} of assignment statement @code{G}.
1204 Return a pointer to the @code{LHS} of assignment statement @code{G}.
1208 Return the first operand on the @code{RHS} of assignment statement @code{G}.
1212 Return the address of the first operand on the @code{RHS} of assignment
1213 statement @code{G}.
1217 Return the second operand on the @code{RHS} of assignment statement @code{G}.
1221 Return the address of the second operand on the @code{RHS} of assignment
1222 statement @code{G}.
1226 Return the third operand on the @code{RHS} of assignment statement @code{G}.
1230 Return the address of the third operand on the @code{RHS} of assignment
1231 statement @code{G}.
1235 Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
1239 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
1240 statement @code{G}.
1244 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
1245 statement @code{G}.
1249 Set @code{RHS} to be the third operand on the @code{RHS} of assignment
1250 statement @code{G}.
1254 Return true if @code{S} is a type-cast assignment.
1258 @node @code{GIMPLE_BIND}
1259 @subsection @code{GIMPLE_BIND}
1260 @cindex @code{GIMPLE_BIND}
1264 Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
1265 and a body of statements in sequence @code{BODY}.
1269 Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
1273 Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
1274 statement @code{G}.
1278 Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
1279 statement @code{G}.
1283 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
1284 @code{G}.
1289 Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
1293 Append a statement to the end of a @code{GIMPLE_BIND}'s body.
1298 Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
1303 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
1304 @code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
1308 Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
1309 statement @code{G}.
1313 @node @code{GIMPLE_CALL}
1314 @subsection @code{GIMPLE_CALL}
1315 @cindex @code{GIMPLE_CALL}
1319 Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN}
1320 must be either a @code{FUNCTION_DECL} or a gimple call address as
1321 determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of
1322 arguments. The rest of the arguments follow the argument @code{NARGS},
1324 operand is validated with @code{is_gimple_operand}).
1330 Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments
1332 @code{GIMPLE_CALL} is set from the second parameter passed by a caller.
1333 This routine assumes that @code{call_expr} is already in GIMPLE form.
1335 simplification. All the call flags in @code{call_expr} are copied over
1336 to the new @code{GIMPLE_CALL}.
1340 @code{vec<tree>} args)
1341 Identical to @code{gimple_build_call} but the arguments are stored in a
1342 @code{vec<tree>}.
1346 Return the @code{LHS} of call statement @code{G}.
1350 Return a pointer to the @code{LHS} of call statement @code{G}.
1354 Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
1359 statement @code{G}.
1363 Set @code{FN} to be the function called by call statement @code{G}. This has
1369 If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
1370 Otherwise return @code{NULL}. This function is analogous to
1371 @code{get_callee_fndecl} in @code{GENERIC}.
1375 Set the called function to @code{FNDECL}.
1379 Return the type returned by call statement @code{G}.
1383 Return the static chain for call statement @code{G}.
1387 Set @code{CHAIN} to be the static chain for call statement @code{G}.
1391 Return the number of arguments used by call statement @code{G}.
1395 Return the argument at position @code{INDEX} for call statement @code{G}. The
1400 Return a pointer to the argument at position @code{INDEX} for call
1401 statement @code{G}.
1405 Set @code{ARG} to be the argument at position @code{INDEX} for call statement
1406 @code{G}.
1410 Mark call statement @code{S} as being a tail call (i.e., a call just
1416 Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
1420 Return true if @code{S} is a noreturn call.
1425 Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
1426 in the positions marked by the set @code{ARGS_TO_SKIP}.
1430 @node @code{GIMPLE_CATCH}
1431 @subsection @code{GIMPLE_CATCH}
1432 @cindex @code{GIMPLE_CATCH}
1436 Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this
1437 catch handles. @code{HANDLER} is a sequence of statements with the code
1442 Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
1446 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
1447 @code{G}.
1452 of @code{GIMPLE_CATCH} statement @code{G}.
1456 Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
1461 Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
1465 @node @code{GIMPLE_COND}
1466 @subsection @code{GIMPLE_COND}
1467 @cindex @code{GIMPLE_COND}
1471 Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares
1472 @code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
1473 the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
1474 @code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
1475 @code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
1481 Build a @code{GIMPLE_COND} statement from the conditional expression
1482 tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
1486 Return the code of the predicate computed by conditional
1487 statement @code{G}.
1491 enum tree_code code)
1492 Set @code{CODE} to be the predicate code for the conditional statement
1493 @code{G}.
1497 Return the @code{LHS} of the predicate computed by conditional statement
1498 @code{G}.
1502 Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
1503 conditional statement @code{G}.
1507 Return the @code{RHS} operand of the predicate computed by conditional
1508 @code{G}.
1512 Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
1513 conditional statement @code{G}.
1517 Return the label used by conditional statement @code{G} when its
1522 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1527 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1532 Return the label used by conditional statement @code{G} when its
1537 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
1541 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
1544 @node @code{GIMPLE_DEBUG}
1545 @subsection @code{GIMPLE_DEBUG}
1546 @cindex @code{GIMPLE_DEBUG}
1547 @cindex @code{GIMPLE_DEBUG_BIND}
1548 @cindex @code{GIMPLE_DEBUG_BEGIN_STMT}
1549 @cindex @code{GIMPLE_DEBUG_INLINE_ENTRY}
1553 Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND}
1554 @code{subcode}. The effect of this statement is to tell debug
1556 @code{var} is given by @code{value} at that point, and to remain with
1557 that value until @code{var} runs out of scope, a
1560 components of the @code{value} expression change afterwards, the
1564 It is expected that @code{var} be most often a tree for automatic user
1565 variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the
1567 scalarized component of a user variable (@code{ARRAY_REF},
1568 @code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}).
1570 As for @code{value}, it can be an arbitrary tree expression, but it is
1572 @code{RHS}. It is not expected that user variables that could appear
1573 as @code{var} ever appear in @code{value}, because in the latter we'd
1574 have their @code{SSA_NAME}s instead, but even if they were not in SSA
1575 form, user variables appearing in @code{value} are to be regarded as
1576 part of the executable code space, whereas those in @code{var} are to
1577 be regarded as part of the source code space. There is no way to
1578 refer to the value bound to a user variable within a @code{value}
1581 If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
1582 generation machinery is informed that the variable @code{var} is
1588 taken from @code{stmt}, if given.
1592 Return the user variable @var{var} that is bound at @code{stmt}.
1597 @code{stmt}.
1602 variable at @code{stmt}.
1606 Modify the user variable bound at @code{stmt} to @var{var}.
1610 Modify the value bound to the user variable bound at @code{stmt} to
1615 Modify the value bound to the user variable bound at @code{stmt} so
1620 Return @code{TRUE} if @code{stmt} binds a user variable to a value,
1621 and @code{FALSE} if it unbinds the variable.
1625 Build a @code{GIMPLE_DEBUG} statement with
1626 @code{GIMPLE_DEBUG_BEGIN_STMT} @code{subcode}. The effect of this
1628 user statement at the given @code{location} and @code{block} starts at
1636 Build a @code{GIMPLE_DEBUG} statement with
1637 @code{GIMPLE_DEBUG_INLINE_ENTRY} @code{subcode}. The effect of this
1639 function call at @code{location} underwent inline substitution, that
1640 @code{block} is the enclosing lexical block created for the
1647 @node @code{GIMPLE_EH_FILTER}
1648 @subsection @code{GIMPLE_EH_FILTER}
1649 @cindex @code{GIMPLE_EH_FILTER}
1653 Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's
1654 types. @code{FAILURE} is a sequence with the filter's failure action.
1658 Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
1662 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
1663 statement @code{G}.
1667 Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
1673 Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
1678 Set @code{FAILURE} to be the sequence of statements to execute on
1679 failure for @code{GIMPLE_EH_FILTER} @code{G}.
1693 @node @code{GIMPLE_LABEL}
1694 @subsection @code{GIMPLE_LABEL}
1695 @cindex @code{GIMPLE_LABEL}
1698 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
1699 label, @code{LABEL}.
1703 Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
1707 Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
1708 statement @code{G}.
1711 @node @code{GIMPLE_GOTO}
1712 @subsection @code{GIMPLE_GOTO}
1713 @cindex @code{GIMPLE_GOTO}
1716 Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
1720 Return the destination of the unconditional jump @code{G}.
1724 Set @code{DEST} to be the destination of the unconditional jump @code{G}.
1728 @node @code{GIMPLE_NOP}
1729 @subsection @code{GIMPLE_NOP}
1730 @cindex @code{GIMPLE_NOP}
1733 Build a @code{GIMPLE_NOP} statement.
1737 Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
1740 @node @code{GIMPLE_OMP_ATOMIC_LOAD}
1741 @subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
1742 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
1746 Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand
1747 side of the assignment. @code{RHS} is the right-hand side of the
1753 Set the @code{LHS} of an atomic load.
1758 Get the @code{LHS} of an atomic load.
1763 Set the @code{RHS} of an atomic set.
1768 Get the @code{RHS} of an atomic set.
1772 @node @code{GIMPLE_OMP_ATOMIC_STORE}
1773 @subsection @code{GIMPLE_OMP_ATOMIC_STORE}
1774 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
1778 Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
1792 @node @code{GIMPLE_OMP_CONTINUE}
1793 @subsection @code{GIMPLE_OMP_CONTINUE}
1794 @cindex @code{GIMPLE_OMP_CONTINUE}
1798 Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the
1799 definition of the control variable. @code{CONTROL_USE} is the use of
1806 @code{GIMPLE_OMP_CONTINUE} in @code{S}.
1816 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
1817 statement in @code{S}.
1822 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
1823 in @code{S}.
1833 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
1834 in @code{S}.
1838 @node @code{GIMPLE_OMP_CRITICAL}
1839 @subsection @code{GIMPLE_OMP_CRITICAL}
1840 @cindex @code{GIMPLE_OMP_CRITICAL}
1844 Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
1845 statements for which only one thread can execute. @code{NAME} is an
1851 Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
1856 Return a pointer to the name associated with @code{OMP} critical
1857 statement @code{G}.
1862 Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
1865 @node @code{GIMPLE_OMP_FOR}
1866 @subsection @code{GIMPLE_OMP_FOR}
1867 @cindex @code{GIMPLE_OMP_FOR}
1872 Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
1873 inside the for loop. @code{CLAUSES}, are any of the loop
1874 construct's clauses. @code{PRE_BODY} is the
1875 sequence of statements that are loop invariant. @code{INDEX} is the
1876 index variable. @code{INITIAL} is the initial value of @code{INDEX}. @code{FINAL} is
1877 final value of @code{INDEX}. OMP_FOR_COND is the predicate used to
1878 compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression.
1882 Return the clauses associated with @code{OMP_FOR} @code{G}.
1886 Return a pointer to the @code{OMP_FOR} @code{G}.
1890 Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
1894 Return the index variable for @code{OMP_FOR} @code{G}.
1898 Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
1902 Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
1906 Return the initial value for @code{OMP_FOR} @code{G}.
1910 Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
1914 Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
1918 Return the final value for @code{OMP_FOR} @code{G}.
1922 turn a pointer to the final value for @code{OMP_FOR} @code{G}.
1926 Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
1930 Return the increment value for @code{OMP_FOR} @code{G}.
1934 Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
1938 Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
1942 Return the sequence of statements to execute before the @code{OMP_FOR}
1943 statement @code{G} starts.
1947 Set @code{PRE_BODY} to be the sequence of statements to execute before
1948 the @code{OMP_FOR} statement @code{G} starts.
1952 Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
1956 Return the condition code associated with @code{OMP_FOR} @code{G}.
1960 @node @code{GIMPLE_OMP_MASTER}
1961 @subsection @code{GIMPLE_OMP_MASTER}
1962 @cindex @code{GIMPLE_OMP_MASTER}
1965 Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
1970 @node @code{GIMPLE_OMP_ORDERED}
1971 @subsection @code{GIMPLE_OMP_ORDERED}
1972 @cindex @code{GIMPLE_OMP_ORDERED}
1975 Build a @code{GIMPLE_OMP_ORDERED} statement.
1978 @code{BODY} is the sequence of statements inside a loop that will
1982 @node @code{GIMPLE_OMP_PARALLEL}
1983 @subsection @code{GIMPLE_OMP_PARALLEL}
1984 @cindex @code{GIMPLE_OMP_PARALLEL}
1988 Build a @code{GIMPLE_OMP_PARALLEL} statement.
1991 @code{BODY} is sequence of statements which are executed in parallel.
1992 @code{CLAUSES}, are the @code{OMP} parallel construct's clauses. @code{CHILD_FN} is
1994 @code{DATA_ARG} are the shared data argument(s).
1997 Return true if @code{OMP} parallel statement @code{G} has the
1998 @code{GF_OMP_PARALLEL_COMBINED} flag set.
2002 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
2003 @code{G}.
2007 Return the body for the @code{OMP} statement @code{G}.
2011 Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
2015 Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
2020 Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
2025 Set @code{CLAUSES} to be the list of clauses associated with
2026 @code{OMP_PARALLEL} @code{G}.
2031 Return the child function used to hold the body of @code{OMP_PARALLEL}
2032 @code{G}.
2038 @code{OMP_PARALLEL} @code{G}.
2043 Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
2049 from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
2054 Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
2059 Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
2063 @node @code{GIMPLE_OMP_RETURN}
2064 @subsection @code{GIMPLE_OMP_RETURN}
2065 @cindex @code{GIMPLE_OMP_RETURN}
2068 Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
2073 Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
2078 Return true if @code{OMP} return statement @code{G} has the
2079 @code{GF_OMP_RETURN_NOWAIT} flag set.
2082 @node @code{GIMPLE_OMP_SECTION}
2083 @subsection @code{GIMPLE_OMP_SECTION}
2084 @cindex @code{GIMPLE_OMP_SECTION}
2087 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
2090 @code{BODY} is the sequence of statements in the section.
2093 Return true if @code{OMP} section statement @code{G} has the
2094 @code{GF_OMP_SECTION_LAST} flag set.
2098 Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
2101 @node @code{GIMPLE_OMP_SECTIONS}
2102 @subsection @code{GIMPLE_OMP_SECTIONS}
2103 @cindex @code{GIMPLE_OMP_SECTIONS}
2107 Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
2108 section statements. @code{CLAUSES} are any of the @code{OMP} sections
2115 Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
2120 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2125 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2129 Set @code{CONTROL} to be the set of clauses associated with the
2130 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2134 Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
2138 Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
2142 Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
2143 @code{G}.
2147 @node @code{GIMPLE_OMP_SINGLE}
2148 @subsection @code{GIMPLE_OMP_SINGLE}
2149 @cindex @code{GIMPLE_OMP_SINGLE}
2153 Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
2154 statements that will be executed once. @code{CLAUSES} are any of the
2155 @code{OMP} single construct's clauses: private, firstprivate,
2160 Return the clauses associated with @code{OMP_SINGLE} @code{G}.
2164 Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
2169 Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
2173 @node @code{GIMPLE_PHI}
2174 @subsection @code{GIMPLE_PHI}
2175 @cindex @code{GIMPLE_PHI}
2178 Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
2182 Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
2184 holding @code{G}.
2188 Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2192 Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2196 Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2200 Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
2201 @code{GIMPLE_PHI} @code{G}.
2206 Set @code{PHIARG} to be the argument corresponding to incoming edge
2207 @code{INDEX} for @code{GIMPLE_PHI} @code{G}.
2210 @node @code{GIMPLE_RESX}
2211 @subsection @code{GIMPLE_RESX}
2212 @cindex @code{GIMPLE_RESX}
2215 Build a @code{GIMPLE_RESX} statement which is a statement. This
2217 function call or a branch is needed. @code{REGION} is the exception
2222 Return the region number for @code{GIMPLE_RESX} @code{G}.
2226 Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
2229 @node @code{GIMPLE_RETURN}
2230 @subsection @code{GIMPLE_RETURN}
2231 @cindex @code{GIMPLE_RETURN}
2234 Build a @code{GIMPLE_RETURN} statement whose return value is retval.
2238 Return the return value for @code{GIMPLE_RETURN} @code{G}.
2243 Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
2246 @node @code{GIMPLE_SWITCH}
2247 @subsection @code{GIMPLE_SWITCH}
2248 @cindex @code{GIMPLE_SWITCH}
2251 tree default_label, @code{vec}<tree> *args)
2252 Build a @code{GIMPLE_SWITCH} statement. @code{INDEX} is the index variable
2253 to switch on, and @code{DEFAULT_LABEL} represents the default label.
2254 @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
2255 non-default case labels. Each label is a tree of code @code{CASE_LABEL_EXPR}.
2261 @code{G}.
2266 Set @code{NLABELS} to be the number of labels for the switch statement
2267 @code{G}.
2271 Return the index variable used by the switch statement @code{G}.
2276 Set @code{INDEX} to be the index variable for switch statement @code{G}.
2281 Return the label numbered @code{INDEX}. The default label is 0, followed
2287 Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
2302 @node @code{GIMPLE_TRY}
2303 @subsection @code{GIMPLE_TRY}
2304 @cindex @code{GIMPLE_TRY}
2308 Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the
2309 expression to evaluate. @code{CLEANUP} is a sequence of statements to
2310 run at clean-up time. @code{KIND} is the enumeration value
2311 @code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
2312 or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
2317 Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
2318 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
2322 Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2326 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
2327 @code{G}.
2332 @code{GIMPLE_TRY} @code{G}.
2337 Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2341 Set @code{EVAL} to be the sequence of statements to use as the body for
2342 @code{GIMPLE_TRY} @code{G}.
2347 Set @code{CLEANUP} to be the sequence of statements to use as the
2348 cleanup body for @code{GIMPLE_TRY} @code{G}.
2351 @node @code{GIMPLE_WITH_CLEANUP_EXPR}
2352 @subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
2353 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
2356 Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement. @code{CLEANUP} is the
2361 Return the cleanup sequence for cleanup statement @code{G}.
2365 Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
2369 Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2373 Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2381 GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
2382 used in @code{GENERIC}. They are used to chain statements together, and
2386 GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
2388 The type for a sequence pointer is @code{gimple_seq} which is the same
2389 as struct @code{gimple_sequence} *. When declaring a local sequence,
2390 you can define a local variable of type struct @code{gimple_sequence}.
2392 heap, use the function @code{gimple_seq_alloc} documented below.
2400 Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
2401 not @code{NULL}. If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
2405 Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
2406 @code{NULL}. If *@code{DEST} is @code{NULL}, allocate a new sequence before
2411 Perform a deep copy of sequence @code{SRC} and return the result.
2415 Reverse the order of the statements in the sequence @code{SEQ}. Return
2416 @code{SEQ}.
2420 Return the first statement in sequence @code{S}.
2424 Return the last statement in sequence @code{S}.
2428 Set the last statement in sequence @code{S} to the statement in @code{LAST}.
2432 Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
2436 Initialize sequence @code{S} to an empty sequence.
2445 Copy the sequence @code{SRC} into the sequence @code{DEST}.
2449 Return true if the sequence @code{S} is empty.
2453 Returns the sequence of statements in @code{BB}.
2457 Sets the sequence of statements in @code{BB} to @code{SEQ}.
2461 Determine whether @code{SEQ} contains exactly one statement.
2469 through statements in a sequence. Given a sequence @code{SEQ}, here is
2478 /* Do something with gimple statement @code{G}. */
2489 @code{gsi_start_bb} and @code{gsi_last_bb}.
2492 @code{gsi_iterator_update}. The valid options for this enumeration are:
2495 @item @code{GSI_NEW_STMT}
2498 @item @code{GSI_SAME_STMT}
2501 @item @code{GSI_CONTINUE_LINKING}
2510 Return a new iterator pointing to the sequence @code{SEQ}'s first
2511 statement. If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
2512 Use @code{gsi_start_bb} instead when the iterator needs to always have
2518 block @code{BB}.
2523 sequence @code{SEQ}. If @code{SEQ} is empty, the iterator's basic block is
2524 @code{NULL}. Use @code{gsi_last_bb} instead when the iterator needs to always
2530 block @code{BB}.
2534 Return @code{TRUE} if at the end of @code{I}.
2538 Return @code{TRUE} if we're one statement before the end of @code{I}.
2555 non-label statement in block @code{BB}.
2572 updated to point to the next statement. When @code{REMOVE_EH_INFO} is
2573 true we remove the statement pointed to by iterator @code{I} from the @code{EH}
2574 tables. Otherwise we do not modify the @code{EH} tables. Generally,
2575 @code{REMOVE_EH_INFO} should be true when the statement is going to be
2576 removed from the @code{IL} and not reinserted elsewhere.
2580 Links the sequence of statements @code{SEQ} before the statement pointed
2581 by iterator @code{I}. @code{MODE} indicates what to do with the iterator
2582 after insertion (see @code{enum gsi_iterator_update} above).
2586 Links statement @code{G} before the statement pointed-to by iterator @code{I}.
2587 Updates iterator @code{I} according to @code{MODE}.
2592 Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
2593 @code{MODE} is as in @code{gsi_insert_after}.
2598 Links statement @code{G} after the statement pointed-to by iterator @code{I}.
2599 @code{MODE} is as in @code{gsi_insert_after}.
2603 Move all statements in the sequence after @code{I} to a new sequence.
2608 Move all statements in the sequence before @code{I} to a new sequence.
2614 Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO}
2621 Insert statement @code{STMT} before the statement pointed-to by iterator
2622 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2623 specifies how to update iterator @code{I} after insertion (see enum
2624 @code{gsi_iterator_update}).
2629 Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
2634 Insert statement @code{STMT} after the statement pointed-to by iterator
2635 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2636 specifies how to update iterator @code{I} after insertion (see enum
2637 @code{gsi_iterator_update}).
2642 Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
2646 Finds iterator for @code{STMT}.
2651 Move the statement at @code{FROM} so it comes right after the statement
2652 at @code{TO}.
2657 Move the statement at @code{FROM} so it comes right before the statement
2658 at @code{TO}.
2663 Move the statement at @code{FROM} to the end of basic block @code{BB}.
2667 Add @code{STMT} to the pending list of edge @code{E}. No actual insertion is
2668 made until a call to @code{gsi_commit_edge_inserts}() is made.
2672 Add the sequence of statements in @code{SEQ} to the pending list of edge
2673 @code{E}. No actual insertion is made until a call to
2674 @code{gsi_commit_edge_inserts}() is made.
2678 Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}. If a new
2683 Commit insertions pending at edge @code{E}. If a new block is created,
2684 set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
2693 @node Adding a new GIMPLE statement code
2694 @section Adding a new GIMPLE statement code
2695 @cindex Adding a new GIMPLE statement code
2697 The first step in adding a new GIMPLE statement code, is
2698 modifying the file @code{gimple.def}, which contains all the GIMPLE
2700 located in @code{gimple.h}. This in turn, will require you to add a
2701 corresponding @code{GTY} tag in @code{gsstruct.def}, and code to handle
2702 this tag in @code{gss_for_code} which is located in @code{gimple.c}.
2705 structure you created in @code{gimple.h}, you need to add a case to
2706 handle your new GIMPLE statement in @code{gimple_size} which is located
2707 in @code{gimple.c}.
2710 gimple statement in @code{gimple.c}. The function should be called
2711 @code{gimple_build_@var{new-tuple-name}}, and should return the new tuple
2716 @code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
2717 corresponding prototype in @code{gimple.h}.
2720 in @code{gimple.texi}.
2728 sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
2730 statement: @code{walk_gimple_op}.
2734 This function is used to walk the current statement in @code{GSI},
2735 optionally using traversal state stored in @code{WI}. If @code{WI} is @code{NULL}, no
2738 The callback @code{CALLBACK_STMT} is called. If @code{CALLBACK_STMT} returns
2743 If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
2744 called on each operand of the statement via @code{walk_gimple_op}. If
2745 @code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
2749 @code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
2755 Use this function to walk the operands of statement @code{STMT}. Every
2756 operand is walked via @code{walk_tree} with optional state information
2757 in @code{WI}.
2759 @code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
2760 Additional parameters to @code{walk_tree} must be stored in @code{WI}. For
2761 each operand @code{OP}, @code{walk_tree} is called as:
2764 walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{PSET})
2767 If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
2769 the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
2776 This function walks all the statements in the sequence @code{SEQ}
2777 calling @code{walk_gimple_stmt} on each one. @code{WI} is as in
2778 @code{walk_gimple_stmt}. If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
2780 are walked and @code{NULL_TREE} returned.