1 @c Copyright (c) 2008, 2009 Free Software Foundation, Inc.
2 @c Free Software Foundation, Inc.
3 @c This is part of the GCC manual.
4 @c For copying conditions, see the file gcc.texi.
10 GIMPLE is a three-address representation derived from GENERIC by
11 breaking down GENERIC expressions into tuples of no more than 3
12 operands (with some exceptions like function calls). GIMPLE was
13 heavily influenced by the SIMPLE IL used by the McCAT compiler
14 project at McGill University, though we have made some different
15 choices. For one thing, SIMPLE doesn't support @code{goto}.
17 Temporaries are introduced to hold intermediate values needed to
18 compute complex expressions. Additionally, all the control
19 structures used in GENERIC are lowered into conditional jumps,
20 lexical scopes are removed and exception regions are converted
21 into an on the side exception region tree.
23 The compiler pass which converts GENERIC into GIMPLE is referred to as
24 the @samp{gimplifier}. The gimplifier works recursively, generating
25 GIMPLE tuples out of the original GENERIC expressions.
27 One of the early implementation strategies used for the GIMPLE
28 representation was to use the same internal data structures used
29 by front ends to represent parse trees. This simplified
30 implementation because we could leverage existing functionality
31 and interfaces. However, GIMPLE is a much more restrictive
32 representation than abstract syntax trees (AST), therefore it
33 does not require the full structural complexity provided by the
34 main tree data structure.
36 The GENERIC representation of a function is stored in the
37 @code{DECL_SAVED_TREE} field of the associated @code{FUNCTION_DECL}
38 tree node. It is converted to GIMPLE by a call to
39 @code{gimplify_function_tree}.
41 If a front end wants to include language-specific tree codes in the tree
42 representation which it provides to the back end, it must provide a
43 definition of @code{LANG_HOOKS_GIMPLIFY_EXPR} which knows how to
44 convert the front end trees to GIMPLE@. Usually such a hook will involve
45 much of the same code for expanding front end trees to RTL@. This function
46 can return fully lowered GIMPLE, or it can return GENERIC trees and let the
47 main gimplifier lower them the rest of the way; this is often simpler.
48 GIMPLE that is not fully lowered is known as ``High GIMPLE'' and
49 consists of the IL before the pass @code{pass_lower_cf}. High GIMPLE
50 contains some container statements like lexical scopes
51 (represented by @code{GIMPLE_BIND}) and nested expressions (e.g.,
52 @code{GIMPLE_TRY}), while ``Low GIMPLE'' exposes all of the
53 implicit jumps for control and exception expressions directly in
54 the IL and EH region trees.
56 The C and C++ front ends currently convert directly from front end
57 trees to GIMPLE, and hand that off to the back end rather than first
58 converting to GENERIC@. Their gimplifier hooks know about all the
59 @code{_STMT} nodes and how to convert them to GENERIC forms. There
60 was some work done on a genericization pass which would run first, but
61 the existence of @code{STMT_EXPR} meant that in order to convert all
62 of the C statements into GENERIC equivalents would involve walking the
63 entire tree anyway, so it was simpler to lower all the way. This
64 might change in the future if someone writes an optimization pass
65 which would work better with higher-level trees, but currently the
66 optimizers all expect GIMPLE@.
68 You can request to dump a C-like representation of the GIMPLE form
69 with the flag @option{-fdump-tree-gimple}.
72 * Tuple representation::
73 * GIMPLE instruction set::
74 * GIMPLE Exception Handling::
77 * Manipulating GIMPLE statements::
78 * Tuple specific accessors::
80 * Sequence iterators::
81 * Adding a new GIMPLE statement code::
82 * Statement and operand traversals::
85 @node Tuple representation
86 @section Tuple representation
89 GIMPLE instructions are tuples of variable size divided in two
90 groups: a header describing the instruction and its locations,
91 and a variable length body with all the operands. Tuples are
92 organized into a hierarchy with 3 main classes of tuples.
94 @subsection @code{gimple_statement_base} (gsbase)
95 @cindex gimple_statement_base
97 This is the root of the hierarchy, it holds basic information
98 needed by most GIMPLE statements. There are some fields that
99 may not be relevant to every GIMPLE statement, but those were
100 moved into the base structure to take advantage of holes left by
101 other fields (thus making the structure more compact). The
102 structure takes 4 words (32 bytes) on 64 bit hosts:
104 @multitable {@code{references_memory_p}} {Size (bits)}
105 @item Field @tab Size (bits)
106 @item @code{code} @tab 8
107 @item @code{subcode} @tab 16
108 @item @code{no_warning} @tab 1
109 @item @code{visited} @tab 1
110 @item @code{nontemporal_move} @tab 1
111 @item @code{plf} @tab 2
112 @item @code{modified} @tab 1
113 @item @code{has_volatile_ops} @tab 1
114 @item @code{references_memory_p} @tab 1
115 @item @code{uid} @tab 32
116 @item @code{location} @tab 32
117 @item @code{num_ops} @tab 32
118 @item @code{bb} @tab 64
119 @item @code{block} @tab 63
120 @item Total size @tab 32 bytes
125 Main identifier for a GIMPLE instruction.
128 Used to distinguish different variants of the same basic
129 instruction or provide flags applicable to a given code. The
130 @code{subcode} flags field has different uses depending on the code of
131 the instruction, but mostly it distinguishes instructions of the
132 same family. The most prominent use of this field is in
133 assignments, where subcode indicates the operation done on the
134 RHS of the assignment. For example, a = b + c is encoded as
135 @code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
137 @item @code{no_warning}
138 Bitflag to indicate whether a warning has already been issued on
142 General purpose ``visited'' marker. Set and cleared by each pass
145 @item @code{nontemporal_move}
146 Bitflag used in assignments that represent non-temporal moves.
147 Although this bitflag is only used in assignments, it was moved
148 into the base to take advantage of the bit holes left by the
152 Pass Local Flags. This 2-bit mask can be used as general purpose
153 markers by any pass. Passes are responsible for clearing and
154 setting these two flags accordingly.
156 @item @code{modified}
157 Bitflag to indicate whether the statement has been modified.
158 Used mainly by the operand scanner to determine when to re-scan a
159 statement for operands.
161 @item @code{has_volatile_ops}
162 Bitflag to indicate whether this statement contains operands that
163 have been marked volatile.
165 @item @code{references_memory_p}
166 Bitflag to indicate whether this statement contains memory
167 references (i.e., its operands are either global variables, or
168 pointer dereferences or anything that must reside in memory).
171 This is an unsigned integer used by passes that want to assign
172 IDs to every statement. These IDs must be assigned and used by
175 @item @code{location}
176 This is a @code{location_t} identifier to specify source code
177 location for this statement. It is inherited from the front
181 Number of operands that this statement has. This specifies the
182 size of the operand vector embedded in the tuple. Only used in
183 some tuples, but it is declared in the base tuple to take
184 advantage of the 32-bit hole left by the previous fields.
187 Basic block holding the instruction.
190 Lexical block holding this statement. Also used for debug
191 information generation.
194 @subsection @code{gimple_statement_with_ops}
195 @cindex gimple_statement_with_ops
197 This tuple is actually split in two:
198 @code{gimple_statement_with_ops_base} and
199 @code{gimple_statement_with_ops}. This is needed to accommodate the
200 way the operand vector is allocated. The operand vector is
201 defined to be an array of 1 element. So, to allocate a dynamic
202 number of operands, the memory allocator (@code{gimple_alloc}) simply
203 allocates enough memory to hold the structure itself plus @code{N
204 - 1} operands which run ``off the end'' of the structure. For
205 example, to allocate space for a tuple with 3 operands,
206 @code{gimple_alloc} reserves @code{sizeof (struct
207 gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
209 On the other hand, several fields in this tuple need to be shared
210 with the @code{gimple_statement_with_memory_ops} tuple. So, these
211 common fields are placed in @code{gimple_statement_with_ops_base} which
212 is then inherited from the other two tuples.
215 @multitable {@code{addresses_taken}} {56 + 8 * @code{num_ops} bytes}
216 @item @code{gsbase} @tab 256
217 @item @code{addresses_taken} @tab 64
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 56 + 8 * @code{num_ops} bytes
226 Inherited from @code{struct gimple_statement_base}.
228 @item @code{addresses_taken}
229 Bitmap holding the UIDs of all the @code{VAR_DECL}s whose addresses are
230 taken by this statement. For example, a statement of the form
231 @code{p = &b} will have the UID for symbol @code{b} in this set.
234 Array of pointers into the operand array indicating all the slots that
235 contain a variable written-to by the statement. This array is
236 also used for immediate use chaining. Note that it would be
237 possible to not rely on this array, but the changes required to
238 implement this are pretty invasive.
241 Similar to @code{def_ops} but for variables read by the statement.
244 Array of trees with @code{num_ops} slots.
247 @subsection @code{gimple_statement_with_memory_ops}
249 This tuple is essentially identical to @code{gimple_statement_with_ops},
250 except that it contains 4 additional fields to hold vectors
251 related memory stores and loads. Similar to the previous case,
252 the structure is split in two to accommodate for the operand
253 vector (@code{gimple_statement_with_memory_ops_base} and
254 @code{gimple_statement_with_memory_ops}).
257 @multitable {@code{addresses_taken}} {88 + 8 * @code{num_ops} bytes}
258 @item Field @tab Size (bits)
259 @item @code{gsbase} @tab 256
260 @item @code{addresses_taken} @tab 64
261 @item @code{def_ops} @tab 64
262 @item @code{use_ops} @tab 64
263 @item @code{vdef_ops} @tab 64
264 @item @code{vuse_ops} @tab 64
265 @item @code{stores} @tab 64
266 @item @code{loads} @tab 64
267 @item @code{op} @tab @code{num_ops} * 64
268 @item Total size @tab 88 + 8 * @code{num_ops} bytes
272 @item @code{vdef_ops}
273 Similar to @code{def_ops} but for @code{VDEF} operators. There is
274 one entry per memory symbol written by this statement. This is
275 used to maintain the memory SSA use-def and def-def chains.
277 @item @code{vuse_ops}
278 Similar to @code{use_ops} but for @code{VUSE} operators. There is
279 one entry per memory symbol loaded by this statement. This is
280 used to maintain the memory SSA use-def chains.
283 Bitset with all the UIDs for the symbols written-to by the
284 statement. This is different than @code{vdef_ops} in that all the
285 affected symbols are mentioned in this set. If memory
286 partitioning is enabled, the @code{vdef_ops} vector will refer to memory
287 partitions. Furthermore, no SSA information is stored in this
291 Similar to @code{stores}, but for memory loads. (Note that there
292 is some amount of redundancy here, it should be possible to
293 reduce memory utilization further by removing these sets).
296 All the other tuples are defined in terms of these three basic
297 ones. Each tuple will add some fields. The main gimple type
298 is defined to be the union of all these structures (@code{GTY} markers
302 union gimple_statement_d
304 struct gimple_statement_base gsbase;
305 struct gimple_statement_with_ops gsops;
306 struct gimple_statement_with_memory_ops gsmem;
307 struct gimple_statement_omp omp;
308 struct gimple_statement_bind gimple_bind;
309 struct gimple_statement_catch gimple_catch;
310 struct gimple_statement_eh_filter gimple_eh_filter;
311 struct gimple_statement_phi gimple_phi;
312 struct gimple_statement_resx gimple_resx;
313 struct gimple_statement_try gimple_try;
314 struct gimple_statement_wce gimple_wce;
315 struct gimple_statement_asm gimple_asm;
316 struct gimple_statement_omp_critical gimple_omp_critical;
317 struct gimple_statement_omp_for gimple_omp_for;
318 struct gimple_statement_omp_parallel gimple_omp_parallel;
319 struct gimple_statement_omp_task gimple_omp_task;
320 struct gimple_statement_omp_sections gimple_omp_sections;
321 struct gimple_statement_omp_single gimple_omp_single;
322 struct gimple_statement_omp_continue gimple_omp_continue;
323 struct gimple_statement_omp_atomic_load gimple_omp_atomic_load;
324 struct gimple_statement_omp_atomic_store gimple_omp_atomic_store;
329 @node GIMPLE instruction set
330 @section GIMPLE instruction set
331 @cindex GIMPLE instruction set
333 The following table briefly describes the GIMPLE instruction set.
335 @multitable {@code{GIMPLE_CHANGE_DYNAMIC_TYPE}} {High GIMPLE} {Low GIMPLE}
336 @item Instruction @tab High GIMPLE @tab Low GIMPLE
337 @item @code{GIMPLE_ASM} @tab x @tab x
338 @item @code{GIMPLE_ASSIGN} @tab x @tab x
339 @item @code{GIMPLE_BIND} @tab x @tab
340 @item @code{GIMPLE_CALL} @tab x @tab x
341 @item @code{GIMPLE_CATCH} @tab x @tab
342 @item @code{GIMPLE_CHANGE_DYNAMIC_TYPE} @tab x @tab x
343 @item @code{GIMPLE_COND} @tab x @tab x
344 @item @code{GIMPLE_EH_FILTER} @tab x @tab
345 @item @code{GIMPLE_GOTO} @tab x @tab x
346 @item @code{GIMPLE_LABEL} @tab x @tab x
347 @item @code{GIMPLE_NOP} @tab x @tab x
348 @item @code{GIMPLE_OMP_ATOMIC_LOAD} @tab x @tab x
349 @item @code{GIMPLE_OMP_ATOMIC_STORE} @tab x @tab x
350 @item @code{GIMPLE_OMP_CONTINUE} @tab x @tab x
351 @item @code{GIMPLE_OMP_CRITICAL} @tab x @tab x
352 @item @code{GIMPLE_OMP_FOR} @tab x @tab x
353 @item @code{GIMPLE_OMP_MASTER} @tab x @tab x
354 @item @code{GIMPLE_OMP_ORDERED} @tab x @tab x
355 @item @code{GIMPLE_OMP_PARALLEL} @tab x @tab x
356 @item @code{GIMPLE_OMP_RETURN} @tab x @tab x
357 @item @code{GIMPLE_OMP_SECTION} @tab x @tab x
358 @item @code{GIMPLE_OMP_SECTIONS} @tab x @tab x
359 @item @code{GIMPLE_OMP_SECTIONS_SWITCH} @tab x @tab x
360 @item @code{GIMPLE_OMP_SINGLE} @tab x @tab x
361 @item @code{GIMPLE_PHI} @tab @tab x
362 @item @code{GIMPLE_RESX} @tab @tab x
363 @item @code{GIMPLE_RETURN} @tab x @tab x
364 @item @code{GIMPLE_SWITCH} @tab x @tab x
365 @item @code{GIMPLE_TRY} @tab x @tab
368 @node GIMPLE Exception Handling
369 @section Exception Handling
370 @cindex GIMPLE Exception Handling
372 Other exception handling constructs are represented using
373 @code{GIMPLE_TRY_CATCH}. @code{GIMPLE_TRY_CATCH} has two operands. The
374 first operand is a sequence of statements to execute. If executing
375 these statements does not throw an exception, then the second operand
376 is ignored. Otherwise, if an exception is thrown, then the second
377 operand of the @code{GIMPLE_TRY_CATCH} is checked. The second
378 operand may have the following forms:
382 @item A sequence of statements to execute. When an exception occurs,
383 these statements are executed, and then the exception is rethrown.
385 @item A sequence of @code{GIMPLE_CATCH} statements. Each
386 @code{GIMPLE_CATCH} has a list of applicable exception types and
387 handler code. If the thrown exception matches one of the caught
388 types, the associated handler code is executed. If the handler
389 code falls off the bottom, execution continues after the original
390 @code{GIMPLE_TRY_CATCH}.
392 @item An @code{GIMPLE_EH_FILTER} statement. This has a list of
393 permitted exception types, and code to handle a match failure. If the
394 thrown exception does not match one of the allowed types, the
395 associated match failure code is executed. If the thrown exception
396 does match, it continues unwinding the stack looking for the next
401 Currently throwing an exception is not directly represented in
402 GIMPLE, since it is implemented by calling a function. At some
403 point in the future we will want to add some way to express that
404 the call will throw an exception of a known type.
406 Just before running the optimizers, the compiler lowers the
407 high-level EH constructs above into a set of @samp{goto}s, magic
408 labels, and EH regions. Continuing to unwind at the end of a
409 cleanup is represented with a @code{GIMPLE_RESX}.
416 When gimplification encounters a subexpression that is too
417 complex, it creates a new temporary variable to hold the value of
418 the subexpression, and adds a new statement to initialize it
419 before the current statement. These special temporaries are known
420 as @samp{expression temporaries}, and are allocated using
421 @code{get_formal_tmp_var}. The compiler tries to always evaluate
422 identical expressions into the same temporary, to simplify
423 elimination of redundant calculations.
425 We can only use expression temporaries when we know that it will
426 not be reevaluated before its value is used, and that it will not
427 be otherwise modified@footnote{These restrictions are derived
428 from those in Morgan 4.8.}. Other temporaries can be allocated
429 using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
431 Currently, an expression like @code{a = b + 5} is not reduced any
432 further. We tried converting it to something like
437 but this bloated the representation for minimal benefit. However, a
438 variable which must live in memory cannot appear in an expression; its
439 value is explicitly loaded into a temporary first. Similarly, storing
440 the value of an expression to a memory variable goes through a
447 In general, expressions in GIMPLE consist of an operation and the
448 appropriate number of simple operands; these operands must either be a
449 GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
450 variable. More complex operands are factored out into temporaries, so
461 The same rule holds for arguments to a @code{GIMPLE_CALL}.
463 The target of an assignment is usually a variable, but can also be an
464 @code{INDIRECT_REF} or a compound lvalue as described below.
467 * Compound Expressions::
469 * Conditional Expressions::
470 * Logical Operators::
473 @node Compound Expressions
474 @subsection Compound Expressions
475 @cindex Compound Expressions
477 The left-hand side of a C comma expression is simply moved into a separate
480 @node Compound Lvalues
481 @subsection Compound Lvalues
482 @cindex Compound Lvalues
484 Currently compound lvalues involving array and structure field references
485 are not broken down; an expression like @code{a.b[2] = 42} is not reduced
486 any further (though complex array subscripts are). This restriction is a
487 workaround for limitations in later optimizers; if we were to convert this
495 alias analysis would not remember that the reference to @code{T1[2]} came
496 by way of @code{a.b}, so it would think that the assignment could alias
497 another member of @code{a}; this broke @code{struct-alias-1.c}. Future
498 optimizer improvements may make this limitation unnecessary.
500 @node Conditional Expressions
501 @subsection Conditional Expressions
502 @cindex Conditional Expressions
504 A C @code{?:} expression is converted into an @code{if} statement with
505 each branch assigning to the same temporary. So,
519 The GIMPLE level if-conversion pass re-introduces @code{?:}
520 expression, if appropriate. It is used to vectorize loops with
521 conditions using vector conditional operations.
523 Note that in GIMPLE, @code{if} statements are represented using
524 @code{GIMPLE_COND}, as described below.
526 @node Logical Operators
527 @subsection Logical Operators
528 @cindex Logical Operators
530 Except when they appear in the condition operand of a
531 @code{GIMPLE_COND}, logical `and' and `or' operators are simplified
532 as follows: @code{a = b && c} becomes
541 Note that @code{T1} in this example cannot be an expression temporary,
542 because it has two different assignments.
544 @subsection Manipulating operands
546 All gimple operands are of type @code{tree}. But only certain
547 types of trees are allowed to be used as operand tuples. Basic
548 validation is controlled by the function
549 @code{get_gimple_rhs_class}, which given a tree code, returns an
550 @code{enum} with the following values of type @code{enum
554 @item @code{GIMPLE_INVALID_RHS}
555 The tree cannot be used as a GIMPLE operand.
557 @item @code{GIMPLE_BINARY_RHS}
558 The tree is a valid GIMPLE binary operation.
560 @item @code{GIMPLE_UNARY_RHS}
561 The tree is a valid GIMPLE unary operation.
563 @item @code{GIMPLE_SINGLE_RHS}
564 The tree is a single object, that cannot be split into simpler
565 operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc).
567 This operand class also acts as an escape hatch for tree nodes
568 that may be flattened out into the operand vector, but would need
569 more than two slots on the RHS. For instance, a @code{COND_EXPR}
570 expression of the form @code{(a op b) ? x : y} could be flattened
571 out on the operand vector using 4 slots, but it would also
572 require additional processing to distinguish @code{c = a op b}
573 from @code{c = a op b ? x : y}. Something similar occurs with
574 @code{ASSERT_EXPR}. In time, these special case tree
575 expressions should be flattened into the operand vector.
578 For tree nodes in the categories @code{GIMPLE_BINARY_RHS} and
579 @code{GIMPLE_UNARY_RHS}, they cannot be stored inside tuples directly.
580 They first need to be flattened and separated into individual
581 components. For instance, given the GENERIC expression
587 its tree representation is:
590 MODIFY_EXPR <VAR_DECL <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>
593 In this case, the GIMPLE form for this statement is logically
594 identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
595 on the RHS of the assignment is not represented as a tree,
596 instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree
597 and flattened into the GIMPLE tuple as follows:
600 GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>
603 @subsection Operand vector allocation
605 The operand vector is stored at the bottom of the three tuple
606 structures that accept operands. This means, that depending on
607 the code of a given statement, its operand vector will be at
608 different offsets from the base of the structure. To access
609 tuple operands use the following accessors
611 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
612 Returns the number of operands in statement G.
615 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
616 Returns operand @code{I} from statement @code{G}.
619 @deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
620 Returns a pointer into the operand vector for statement @code{G}. This
621 is computed using an internal table called @code{gimple_ops_offset_}[].
622 This table is indexed by the gimple code of @code{G}.
624 When the compiler is built, this table is filled-in using the
625 sizes of the structures used by each statement code defined in
626 gimple.def. Since the operand vector is at the bottom of the
627 structure, for a gimple code @code{C} the offset is computed as sizeof
628 (struct-of @code{C}) - sizeof (tree).
630 This mechanism adds one memory indirection to every access when
631 using @code{gimple_op}(), if this becomes a bottleneck, a pass can
632 choose to memoize the result from @code{gimple_ops}() and use that to
636 @subsection Operand validation
638 When adding a new operand to a gimple statement, the operand will
639 be validated according to what each tuple accepts in its operand
640 vector. These predicates are called by the
641 @code{gimple_<name>_set_...()}. Each tuple will use one of the
642 following predicates (Note, this list is not exhaustive):
644 @deftypefn {GIMPLE function} is_gimple_operand (tree t)
645 This is the most permissive of the predicates. It essentially
646 checks whether t has a @code{gimple_rhs_class} of @code{GIMPLE_SINGLE_RHS}.
650 @deftypefn {GIMPLE function} is_gimple_val (tree t)
651 Returns true if t is a "GIMPLE value", which are all the
652 non-addressable stack variables (variables for which
653 @code{is_gimple_reg} returns true) and constants (expressions for which
654 @code{is_gimple_min_invariant} returns true).
657 @deftypefn {GIMPLE function} is_gimple_addressable (tree t)
658 Returns true if t is a symbol or memory reference whose address
662 @deftypefn {GIMPLE function} is_gimple_asm_val (tree t)
663 Similar to @code{is_gimple_val} but it also accepts hard registers.
666 @deftypefn {GIMPLE function} is_gimple_call_addr (tree t)
667 Return true if t is a valid expression to use as the function
668 called by a @code{GIMPLE_CALL}.
671 @deftypefn {GIMPLE function} is_gimple_constant (tree t)
672 Return true if t is a valid gimple constant.
675 @deftypefn {GIMPLE function} is_gimple_min_invariant (tree t)
676 Return true if t is a valid minimal invariant. This is different
677 from constants, in that the specific value of t may not be known
678 at compile time, but it is known that it doesn't change (e.g.,
679 the address of a function local variable).
682 @deftypefn {GIMPLE function} is_gimple_min_invariant_address (tree t)
683 Return true if t is an @code{ADDR_EXPR} that does not change once the
688 @subsection Statement validation
690 @deftypefn {GIMPLE function} is_gimple_assign (gimple g)
691 Return true if the code of g is @code{GIMPLE_ASSIGN}.
694 @deftypefn {GIMPLE function} is_gimple_call (gimple g)
695 Return true if the code of g is @code{GIMPLE_CALL}
698 @deftypefn {GIMPLE function} gimple_assign_cast_p (gimple g)
699 Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
703 @node Manipulating GIMPLE statements
704 @section Manipulating GIMPLE statements
705 @cindex Manipulating GIMPLE statements
707 This section documents all the functions available to handle each
708 of the GIMPLE instructions.
710 @subsection Common accessors
711 The following are common accessors for gimple statements.
713 @deftypefn {GIMPLE function} enum gimple_code gimple_code (gimple g)
714 Return the code for statement @code{G}.
717 @deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
718 Return the basic block to which statement @code{G} belongs to.
721 @deftypefn {GIMPLE function} tree gimple_block (gimple g)
722 Return the lexical scope block holding statement @code{G}.
725 @deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
726 Return the type of the main expression computed by @code{STMT}. Return
727 @code{void_type_node} if @code{STMT} computes nothing. This will only return
728 something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
729 @code{GIMPLE_CALL}. For all other tuple codes, it will return
730 @code{void_type_node}.
733 @deftypefn {GIMPLE function} enum tree_code gimple_expr_code (gimple stmt)
734 Return the tree code for the expression computed by @code{STMT}. This
735 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
736 @code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
737 For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
738 For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
739 by the @code{RHS} of the assignment.
742 @deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
743 Set the lexical scope block of @code{G} to @code{BLOCK}.
746 @deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
747 Return locus information for statement @code{G}.
750 @deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
751 Set locus information for statement @code{G}.
754 @deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
755 Return true if @code{G} does not have locus information.
758 @deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
759 Return true if no warnings should be emitted for statement @code{STMT}.
762 @deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
763 Set the visited status on statement @code{STMT} to @code{VISITED_P}.
766 @deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
767 Return the visited status on statement @code{STMT}.
770 @deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
771 Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
774 @deftypefn {GIMPLE function} unsigned int gimple_plf (gimple stmt, enum plf_mask plf)
775 Return the value of pass local flag @code{PLF} on statement @code{STMT}.
778 @deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
779 Return true if statement @code{G} has register or memory operands.
782 @deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
783 Return true if statement @code{G} has memory operands.
786 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
787 Return the number of operands for statement @code{G}.
790 @deftypefn {GIMPLE function} tree *gimple_ops (gimple g)
791 Return the array of operands for statement @code{G}.
794 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
795 Return operand @code{I} for statement @code{G}.
798 @deftypefn {GIMPLE function} tree *gimple_op_ptr (gimple g, unsigned i)
799 Return a pointer to operand @code{I} for statement @code{G}.
802 @deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
803 Set operand @code{I} of statement @code{G} to @code{OP}.
806 @deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
807 Return the set of symbols that have had their address taken by
811 @deftypefn {GIMPLE function} struct def_optype_d *gimple_def_ops (gimple g)
812 Return the set of @code{DEF} operands for statement @code{G}.
815 @deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
816 Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
819 @deftypefn {GIMPLE function} struct use_optype_d *gimple_use_ops (gimple g)
820 Return the set of @code{USE} operands for statement @code{G}.
823 @deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
824 Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
827 @deftypefn {GIMPLE function} struct voptype_d *gimple_vuse_ops (gimple g)
828 Return the set of @code{VUSE} operands for statement @code{G}.
831 @deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
832 Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
835 @deftypefn {GIMPLE function} struct voptype_d *gimple_vdef_ops (gimple g)
836 Return the set of @code{VDEF} operands for statement @code{G}.
839 @deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
840 Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
843 @deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
844 Return the set of symbols loaded by statement @code{G}. Each element of
845 the set is the @code{DECL_UID} of the corresponding symbol.
848 @deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
849 Return the set of symbols stored by statement @code{G}. Each element of
850 the set is the @code{DECL_UID} of the corresponding symbol.
853 @deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
854 Return true if statement @code{G} has operands and the modified field
858 @deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
859 Return true if statement @code{STMT} contains volatile operands.
862 @deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
863 Return true if statement @code{STMT} contains volatile operands.
866 @deftypefn {GIMPLE function} void update_stmt (gimple s)
867 Mark statement @code{S} as modified, and update it.
870 @deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
871 Update statement @code{S} if it has been marked modified.
874 @deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
875 Return a deep copy of statement @code{STMT}.
878 @node Tuple specific accessors
879 @section Tuple specific accessors
880 @cindex Tuple specific accessors
883 * @code{GIMPLE_ASM}::
884 * @code{GIMPLE_ASSIGN}::
885 * @code{GIMPLE_BIND}::
886 * @code{GIMPLE_CALL}::
887 * @code{GIMPLE_CATCH}::
888 * @code{GIMPLE_CHANGE_DYNAMIC_TYPE}::
889 * @code{GIMPLE_COND}::
890 * @code{GIMPLE_EH_FILTER}::
891 * @code{GIMPLE_LABEL}::
892 * @code{GIMPLE_NOP}::
893 * @code{GIMPLE_OMP_ATOMIC_LOAD}::
894 * @code{GIMPLE_OMP_ATOMIC_STORE}::
895 * @code{GIMPLE_OMP_CONTINUE}::
896 * @code{GIMPLE_OMP_CRITICAL}::
897 * @code{GIMPLE_OMP_FOR}::
898 * @code{GIMPLE_OMP_MASTER}::
899 * @code{GIMPLE_OMP_ORDERED}::
900 * @code{GIMPLE_OMP_PARALLEL}::
901 * @code{GIMPLE_OMP_RETURN}::
902 * @code{GIMPLE_OMP_SECTION}::
903 * @code{GIMPLE_OMP_SECTIONS}::
904 * @code{GIMPLE_OMP_SINGLE}::
905 * @code{GIMPLE_PHI}::
906 * @code{GIMPLE_RESX}::
907 * @code{GIMPLE_RETURN}::
908 * @code{GIMPLE_SWITCH}::
909 * @code{GIMPLE_TRY}::
910 * @code{GIMPLE_WITH_CLEANUP_EXPR}::
914 @node @code{GIMPLE_ASM}
915 @subsection @code{GIMPLE_ASM}
916 @cindex @code{GIMPLE_ASM}
918 @deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
919 Build a @code{GIMPLE_ASM} statement. This statement is used for
920 building in-line assembly constructs. @code{STRING} is the assembly
921 code. @code{NINPUT} is the number of register inputs. @code{NOUTPUT} is the
922 number of register outputs. @code{NCLOBBERS} is the number of clobbered
923 registers. The rest of the arguments trees for each input,
924 output, and clobbered registers.
927 @deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
928 Identical to gimple_build_asm, but the arguments are passed in
932 @deftypefn {GIMPLE function} gimple_asm_ninputs (gimple g)
933 Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
936 @deftypefn {GIMPLE function} gimple_asm_noutputs (gimple g)
937 Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
940 @deftypefn {GIMPLE function} gimple_asm_nclobbers (gimple g)
941 Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
944 @deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
945 Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
948 @deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
949 Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
952 @deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
953 Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
956 @deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
957 unsigned index, tree out_op)
958 Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
961 @deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
962 Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
965 @deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
966 Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
969 @deftypefn {GIMPLE function} const char *gimple_asm_string (gimple g)
970 Return the string representing the assembly instruction in
971 @code{GIMPLE_ASM} @code{G}.
974 @deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
975 Return true if @code{G} is an asm statement marked volatile.
978 @deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
979 Mark asm statement @code{G} as volatile.
982 @deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
983 Remove volatile marker from asm statement @code{G}.
986 @node @code{GIMPLE_ASSIGN}
987 @subsection @code{GIMPLE_ASSIGN}
988 @cindex @code{GIMPLE_ASSIGN}
990 @deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
991 Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue
992 passed in lhs. The right-hand side can be either a unary or
993 binary tree expression. The expression tree rhs will be
994 flattened and its operands assigned to the corresponding operand
995 slots in the new statement. This function is useful when you
996 already have a tree expression that you want to convert into a
997 tuple. However, try to avoid building expression trees for the
998 sole purpose of calling this function. If you already have the
999 operands in separate trees, it is better to use
1000 @code{gimple_build_assign_with_ops}.
1004 @deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
1005 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
1009 @code{DST}/@code{SRC} are the destination and source respectively. You can
1010 pass ungimplified trees in @code{DST} or @code{SRC}, in which
1011 case they will be converted to a gimple operand if necessary.
1013 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
1015 @deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
1016 (enum tree_code subcode, tree lhs, tree op1, tree op2)
1017 This function is similar to @code{gimple_build_assign}, but is used to
1018 build a @code{GIMPLE_ASSIGN} statement when the operands of the
1019 right-hand side of the assignment are already split into
1022 The left-hand side is an lvalue passed in lhs. Subcode is the
1023 @code{tree_code} for the right-hand side of the assignment. Op1 and op2
1024 are the operands. If op2 is null, subcode must be a @code{tree_code}
1025 for a unary expression.
1028 @deftypefn {GIMPLE function} enum tree_code gimple_assign_rhs_code (gimple g)
1029 Return the code of the expression computed on the @code{RHS} of
1030 assignment statement @code{G}.
1034 @deftypefn {GIMPLE function} enum gimple_rhs_class gimple_assign_rhs_class (gimple g)
1035 Return the gimple rhs class of the code for the expression
1036 computed on the rhs of assignment statement @code{G}. This will never
1037 return @code{GIMPLE_INVALID_RHS}.
1040 @deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
1041 Return the @code{LHS} of assignment statement @code{G}.
1044 @deftypefn {GIMPLE function} tree *gimple_assign_lhs_ptr (gimple g)
1045 Return a pointer to the @code{LHS} of assignment statement @code{G}.
1048 @deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
1049 Return the first operand on the @code{RHS} of assignment statement @code{G}.
1052 @deftypefn {GIMPLE function} tree *gimple_assign_rhs1_ptr (gimple g)
1053 Return the address of the first operand on the @code{RHS} of assignment
1057 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
1058 Return the second operand on the @code{RHS} of assignment statement @code{G}.
1061 @deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
1062 Return the address of the second operand on the @code{RHS} of assignment
1066 @deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
1067 Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
1070 @deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
1071 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
1075 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
1076 Return the second operand on the @code{RHS} of assignment statement @code{G}.
1079 @deftypefn {GIMPLE function} tree *gimple_assign_rhs2_ptr (gimple g)
1080 Return a pointer to the second operand on the @code{RHS} of assignment
1084 @deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
1085 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
1089 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
1090 Return true if @code{S} is an type-cast assignment.
1094 @node @code{GIMPLE_BIND}
1095 @subsection @code{GIMPLE_BIND}
1096 @cindex @code{GIMPLE_BIND}
1098 @deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
1099 Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
1100 and a body of statements in sequence @code{BODY}.
1103 @deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
1104 Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
1107 @deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
1108 Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
1112 @deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
1113 Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
1117 @deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
1118 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
1122 @deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
1123 Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
1126 @deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
1127 Append a statement to the end of a @code{GIMPLE_BIND}'s body.
1130 @deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
1131 Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
1135 @deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
1136 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
1137 @code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
1140 @deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
1141 Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
1146 @node @code{GIMPLE_CALL}
1147 @subsection @code{GIMPLE_CALL}
1148 @cindex @code{GIMPLE_CALL}
1150 @deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
1151 Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN}
1152 must be either a @code{FUNCTION_DECL} or a gimple call address as
1153 determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of
1154 arguments. The rest of the arguments follow the argument @code{NARGS},
1155 and must be trees that are valid as rvalues in gimple (i.e., each
1156 operand is validated with @code{is_gimple_operand}).
1160 @deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
1161 Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments and the
1162 function are taken from the expression directly. This routine
1163 assumes that @code{call_expr} is already in GIMPLE form. That is, its
1164 operands are GIMPLE values and the function call needs no further
1165 simplification. All the call flags in @code{call_expr} are copied over
1166 to the new @code{GIMPLE_CALL}.
1169 @deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
1170 Identical to @code{gimple_build_call} but the arguments are stored in a
1174 @deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
1175 Return the @code{LHS} of call statement @code{G}.
1178 @deftypefn {GIMPLE function} tree *gimple_call_lhs_ptr (gimple g)
1179 Return a pointer to the @code{LHS} of call statement @code{G}.
1182 @deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
1183 Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
1186 @deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
1187 Return the tree node representing the function called by call
1191 @deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
1192 Set @code{FN} to be the function called by call statement @code{G}. This has
1193 to be a gimple value specifying the address of the called
1197 @deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
1198 If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
1199 Otherwise return @code{NULL}. This function is analogous to
1200 @code{get_callee_fndecl} in @code{GENERIC}.
1203 @deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
1204 Set the called function to @code{FNDECL}.
1207 @deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
1208 Return the type returned by call statement @code{G}.
1211 @deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
1212 Return the static chain for call statement @code{G}.
1215 @deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
1216 Set @code{CHAIN} to be the static chain for call statement @code{G}.
1219 @deftypefn {GIMPLE function} gimple_call_num_args (gimple g)
1220 Return the number of arguments used by call statement @code{G}.
1223 @deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
1224 Return the argument at position @code{INDEX} for call statement @code{G}. The
1225 first argument is 0.
1228 @deftypefn {GIMPLE function} tree *gimple_call_arg_ptr (gimple g, unsigned index)
1229 Return a pointer to the argument at position @code{INDEX} for call
1233 @deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
1234 Set @code{ARG} to be the argument at position @code{INDEX} for call statement
1238 @deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
1239 Mark call statement @code{S} as being a tail call (i.e., a call just
1240 before the exit of a function). These calls are candidate for
1241 tail call optimization.
1244 @deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
1245 Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
1248 @deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
1249 Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
1252 @deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
1253 Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
1256 @deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
1257 Return true if @code{S} is a noreturn call.
1260 @deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
1261 Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
1262 in the positions marked by the set @code{ARGS_TO_SKIP}.
1266 @node @code{GIMPLE_CATCH}
1267 @subsection @code{GIMPLE_CATCH}
1268 @cindex @code{GIMPLE_CATCH}
1270 @deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
1271 Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this
1272 catch handles. @code{HANDLER} is a sequence of statements with the code
1276 @deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
1277 Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
1280 @deftypefn {GIMPLE function} tree *gimple_catch_types_ptr (gimple g)
1281 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
1285 @deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
1286 Return the GIMPLE sequence representing the body of the handler
1287 of @code{GIMPLE_CATCH} statement @code{G}.
1290 @deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
1291 Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
1294 @deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
1295 Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
1298 @node @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
1299 @subsection @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
1300 @cindex @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
1302 @deftypefn {GIMPLE function} gimple gimple_build_cdt (tree type, tree ptr)
1303 Build a @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement. @code{TYPE} is the new
1304 type for the location @code{PTR}.
1307 @deftypefn {GIMPLE function} tree gimple_cdt_new_type (gimple g)
1308 Return the new type set by @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement
1312 @deftypefn {GIMPLE function} tree *gimple_cdt_new_type_ptr (gimple g)
1313 Return a pointer to the new type set by
1314 @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}.
1317 @deftypefn {GIMPLE function} void gimple_cdt_set_new_type (gimple g, tree new_type)
1318 Set @code{NEW_TYPE} to be the type returned by
1319 @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}.
1322 @deftypefn {GIMPLE function} tree gimple_cdt_location (gimple g)
1323 Return the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
1327 @deftypefn {GIMPLE function} tree *gimple_cdt_location_ptr (gimple g)
1328 Return a pointer to the location affected by
1329 @code{GIMPLE_CHANGE_DYNAMIC_TYPE} statement @code{G}.
1332 @deftypefn {GIMPLE function} void gimple_cdt_set_location (gimple g, tree ptr)
1333 Set @code{PTR} to be the location affected by @code{GIMPLE_CHANGE_DYNAMIC_TYPE}
1338 @node @code{GIMPLE_COND}
1339 @subsection @code{GIMPLE_COND}
1340 @cindex @code{GIMPLE_COND}
1342 @deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
1343 Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares
1344 @code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
1345 the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
1346 @code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
1347 @code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
1351 @deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
1352 Build a @code{GIMPLE_COND} statement from the conditional expression
1353 tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
1356 @deftypefn {GIMPLE function} enum tree_code gimple_cond_code (gimple g)
1357 Return the code of the predicate computed by conditional
1361 @deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
1362 Set @code{CODE} to be the predicate code for the conditional statement
1366 @deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
1367 Return the @code{LHS} of the predicate computed by conditional statement
1371 @deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
1372 Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
1373 conditional statement @code{G}.
1376 @deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
1377 Return the @code{RHS} operand of the predicate computed by conditional
1381 @deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
1382 Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
1383 conditional statement @code{G}.
1386 @deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
1387 Return the label used by conditional statement @code{G} when its
1388 predicate evaluates to true.
1391 @deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
1392 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1393 its predicate evaluates to true.
1396 @deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
1397 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1398 its predicate evaluates to false.
1401 @deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
1402 Return the label used by conditional statement @code{G} when its
1403 predicate evaluates to false.
1406 @deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
1407 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
1410 @deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
1411 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
1414 @node @code{GIMPLE_EH_FILTER}
1415 @subsection @code{GIMPLE_EH_FILTER}
1416 @cindex @code{GIMPLE_EH_FILTER}
1418 @deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
1419 Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's
1420 types. @code{FAILURE} is a sequence with the filter's failure action.
1423 @deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
1424 Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
1427 @deftypefn {GIMPLE function} tree *gimple_eh_filter_types_ptr (gimple g)
1428 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
1432 @deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
1433 Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
1437 @deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
1438 Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
1441 @deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
1442 Set @code{FAILURE} to be the sequence of statements to execute on
1443 failure for @code{GIMPLE_EH_FILTER} @code{G}.
1446 @deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
1447 Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
1450 @deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
1451 Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
1455 @node @code{GIMPLE_LABEL}
1456 @subsection @code{GIMPLE_LABEL}
1457 @cindex @code{GIMPLE_LABEL}
1459 @deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
1460 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
1461 label, @code{LABEL}.
1464 @deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
1465 Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
1468 @deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
1469 Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
1474 @deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
1475 Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
1478 @deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
1479 Return the destination of the unconditional jump @code{G}.
1482 @deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
1483 Set @code{DEST} to be the destination of the unconditional jump @code{G}.
1487 @node @code{GIMPLE_NOP}
1488 @subsection @code{GIMPLE_NOP}
1489 @cindex @code{GIMPLE_NOP}
1491 @deftypefn {GIMPLE function} gimple gimple_build_nop (void)
1492 Build a @code{GIMPLE_NOP} statement.
1495 @deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
1496 Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
1499 @node @code{GIMPLE_OMP_ATOMIC_LOAD}
1500 @subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
1501 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
1503 @deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
1504 Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand
1505 side of the assignment. @code{RHS} is the right-hand side of the
1509 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
1510 Set the @code{LHS} of an atomic load.
1513 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
1514 Get the @code{LHS} of an atomic load.
1517 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
1518 Set the @code{RHS} of an atomic set.
1521 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
1522 Get the @code{RHS} of an atomic set.
1526 @node @code{GIMPLE_OMP_ATOMIC_STORE}
1527 @subsection @code{GIMPLE_OMP_ATOMIC_STORE}
1528 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
1530 @deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
1531 Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
1535 @deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
1536 Set the value being stored in an atomic store.
1539 @deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
1540 Return the value being stored in an atomic store.
1543 @node @code{GIMPLE_OMP_CONTINUE}
1544 @subsection @code{GIMPLE_OMP_CONTINUE}
1545 @cindex @code{GIMPLE_OMP_CONTINUE}
1547 @deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
1548 Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the
1549 definition of the control variable. @code{CONTROL_USE} is the use of
1550 the control variable.
1553 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
1554 Return the definition of the control variable on a
1555 @code{GIMPLE_OMP_CONTINUE} in @code{S}.
1558 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
1559 Same as above, but return the pointer.
1562 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
1563 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
1564 statement in @code{S}.
1567 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
1568 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
1572 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
1573 Same as above, but return the pointer.
1576 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
1577 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
1582 @node @code{GIMPLE_OMP_CRITICAL}
1583 @subsection @code{GIMPLE_OMP_CRITICAL}
1584 @cindex @code{GIMPLE_OMP_CRITICAL}
1586 @deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
1587 Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
1588 statements for which only one thread can execute. @code{NAME} is an
1589 optional identifier for this critical block.
1592 @deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
1593 Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
1596 @deftypefn {GIMPLE function} tree *gimple_omp_critical_name_ptr (gimple g)
1597 Return a pointer to the name associated with @code{OMP} critical
1601 @deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
1602 Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
1605 @node @code{GIMPLE_OMP_FOR}
1606 @subsection @code{GIMPLE_OMP_FOR}
1607 @cindex @code{GIMPLE_OMP_FOR}
1609 @deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
1610 tree clauses, tree index, tree initial, tree final, tree incr, @
1611 gimple_seq pre_body, enum tree_code omp_for_cond)
1612 Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
1613 inside the for loop. @code{CLAUSES}, are any of the @code{OMP} loop
1614 construct's clauses: private, firstprivate, lastprivate,
1615 reductions, ordered, schedule, and nowait. @code{PRE_BODY} is the
1616 sequence of statements that are loop invariant. @code{INDEX} is the
1617 index variable. @code{INITIAL} is the initial value of @code{INDEX}. @code{FINAL} is
1618 final value of @code{INDEX}. OMP_FOR_COND is the predicate used to
1619 compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression.
1622 @deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
1623 Return the clauses associated with @code{OMP_FOR} @code{G}.
1626 @deftypefn {GIMPLE function} tree *gimple_omp_for_clauses_ptr (gimple g)
1627 Return a pointer to the @code{OMP_FOR} @code{G}.
1630 @deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
1631 Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
1634 @deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
1635 Return the index variable for @code{OMP_FOR} @code{G}.
1638 @deftypefn {GIMPLE function} tree *gimple_omp_for_index_ptr (gimple g)
1639 Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
1642 @deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
1643 Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
1646 @deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
1647 Return the initial value for @code{OMP_FOR} @code{G}.
1650 @deftypefn {GIMPLE function} tree *gimple_omp_for_initial_ptr (gimple g)
1651 Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
1654 @deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
1655 Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
1658 @deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
1659 Return the final value for @code{OMP_FOR} @code{G}.
1662 @deftypefn {GIMPLE function} tree *gimple_omp_for_final_ptr (gimple g)
1663 turn a pointer to the final value for @code{OMP_FOR} @code{G}.
1666 @deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
1667 Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
1670 @deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
1671 Return the increment value for @code{OMP_FOR} @code{G}.
1674 @deftypefn {GIMPLE function} tree *gimple_omp_for_incr_ptr (gimple g)
1675 Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
1678 @deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
1679 Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
1682 @deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
1683 Return the sequence of statements to execute before the @code{OMP_FOR}
1684 statement @code{G} starts.
1687 @deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
1688 Set @code{PRE_BODY} to be the sequence of statements to execute before
1689 the @code{OMP_FOR} statement @code{G} starts.
1692 @deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
1693 Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
1696 @deftypefn {GIMPLE function} enum tree_code gimple_omp_for_cond (gimple g)
1697 Return the condition code associated with @code{OMP_FOR} @code{G}.
1701 @node @code{GIMPLE_OMP_MASTER}
1702 @subsection @code{GIMPLE_OMP_MASTER}
1703 @cindex @code{GIMPLE_OMP_MASTER}
1705 @deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
1706 Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
1707 statements to be executed by just the master.
1711 @node @code{GIMPLE_OMP_ORDERED}
1712 @subsection @code{GIMPLE_OMP_ORDERED}
1713 @cindex @code{GIMPLE_OMP_ORDERED}
1715 @deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
1716 Build a @code{GIMPLE_OMP_ORDERED} statement.
1719 @code{BODY} is the sequence of statements inside a loop that will
1720 executed in sequence.
1723 @node @code{GIMPLE_OMP_PARALLEL}
1724 @subsection @code{GIMPLE_OMP_PARALLEL}
1725 @cindex @code{GIMPLE_OMP_PARALLEL}
1727 @deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg)
1728 Build a @code{GIMPLE_OMP_PARALLEL} statement.
1731 @code{BODY} is sequence of statements which are executed in parallel.
1732 @code{CLAUSES}, are the @code{OMP} parallel construct's clauses. @code{CHILD_FN} is
1733 the function created for the parallel threads to execute.
1734 @code{DATA_ARG} are the shared data argument(s).
1736 @deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
1737 Return true if @code{OMP} parallel statement @code{G} has the
1738 @code{GF_OMP_PARALLEL_COMBINED} flag set.
1741 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
1742 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
1746 @deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
1747 Return the body for the @code{OMP} statement @code{G}.
1750 @deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
1751 Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
1754 @deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
1755 Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
1758 @deftypefn {GIMPLE function} tree *gimple_omp_parallel_clauses_ptr (gimple g)
1759 Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
1762 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
1763 Set @code{CLAUSES} to be the list of clauses associated with
1764 @code{OMP_PARALLEL} @code{G}.
1767 @deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
1768 Return the child function used to hold the body of @code{OMP_PARALLEL}
1772 @deftypefn {GIMPLE function} tree *gimple_omp_parallel_child_fn_ptr (gimple g)
1773 Return a pointer to the child function used to hold the body of
1774 @code{OMP_PARALLEL} @code{G}.
1777 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
1778 Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
1781 @deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
1782 Return the artificial argument used to send variables and values
1783 from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
1786 @deftypefn {GIMPLE function} tree *gimple_omp_parallel_data_arg_ptr (gimple g)
1787 Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
1790 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
1791 Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
1794 @deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt)
1795 Returns true when the gimple statement @code{STMT} is any of the OpenMP
1800 @node @code{GIMPLE_OMP_RETURN}
1801 @subsection @code{GIMPLE_OMP_RETURN}
1802 @cindex @code{GIMPLE_OMP_RETURN}
1804 @deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
1805 Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
1809 @deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
1810 Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
1814 @deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
1815 Return true if @code{OMP} return statement @code{G} has the
1816 @code{GF_OMP_RETURN_NOWAIT} flag set.
1819 @node @code{GIMPLE_OMP_SECTION}
1820 @subsection @code{GIMPLE_OMP_SECTION}
1821 @cindex @code{GIMPLE_OMP_SECTION}
1823 @deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
1824 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
1827 @code{BODY} is the sequence of statements in the section.
1829 @deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
1830 Return true if @code{OMP} section statement @code{G} has the
1831 @code{GF_OMP_SECTION_LAST} flag set.
1834 @deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
1835 Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
1838 @node @code{GIMPLE_OMP_SECTIONS}
1839 @subsection @code{GIMPLE_OMP_SECTIONS}
1840 @cindex @code{GIMPLE_OMP_SECTIONS}
1842 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
1843 Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
1844 section statements. @code{CLAUSES} are any of the @code{OMP} sections
1845 construct's clauses: private, firstprivate, lastprivate,
1846 reduction, and nowait.
1850 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
1851 Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
1854 @deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
1855 Return the control variable associated with the
1856 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
1859 @deftypefn {GIMPLE function} tree *gimple_omp_sections_control_ptr (gimple g)
1860 Return a pointer to the clauses associated with the
1861 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
1864 @deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
1865 Set @code{CONTROL} to be the set of clauses associated with the
1866 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
1869 @deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
1870 Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
1873 @deftypefn {GIMPLE function} tree *gimple_omp_sections_clauses_ptr (gimple g)
1874 Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
1877 @deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
1878 Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
1883 @node @code{GIMPLE_OMP_SINGLE}
1884 @subsection @code{GIMPLE_OMP_SINGLE}
1885 @cindex @code{GIMPLE_OMP_SINGLE}
1887 @deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
1888 Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
1889 statements that will be executed once. @code{CLAUSES} are any of the
1890 @code{OMP} single construct's clauses: private, firstprivate,
1891 copyprivate, nowait.
1894 @deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
1895 Return the clauses associated with @code{OMP_SINGLE} @code{G}.
1898 @deftypefn {GIMPLE function} tree *gimple_omp_single_clauses_ptr (gimple g)
1899 Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
1902 @deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
1903 Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
1907 @node @code{GIMPLE_PHI}
1908 @subsection @code{GIMPLE_PHI}
1909 @cindex @code{GIMPLE_PHI}
1911 @deftypefn {GIMPLE function} gimple make_phi_node (tree var, int len)
1912 Build a @code{PHI} node with len argument slots for variable var.
1915 @deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
1916 Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
1919 @deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
1920 Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
1921 be exactly the number of incoming edges for the basic block
1925 @deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
1926 Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
1929 @deftypefn {GIMPLE function} tree *gimple_phi_result_ptr (gimple g)
1930 Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
1933 @deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
1934 Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
1937 @deftypefn {GIMPLE function} struct phi_arg_d *gimple_phi_arg (gimple g, index)
1938 Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
1939 @code{GIMPLE_PHI} @code{G}.
1942 @deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
1943 Set @code{PHIARG} to be the argument corresponding to incoming edge
1944 @code{INDEX} for @code{GIMPLE_PHI} @code{G}.
1947 @node @code{GIMPLE_RESX}
1948 @subsection @code{GIMPLE_RESX}
1949 @cindex @code{GIMPLE_RESX}
1951 @deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
1952 Build a @code{GIMPLE_RESX} statement which is a statement. This
1953 statement is a placeholder for _Unwind_Resume before we know if a
1954 function call or a branch is needed. @code{REGION} is the exception
1955 region from which control is flowing.
1958 @deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
1959 Return the region number for @code{GIMPLE_RESX} @code{G}.
1962 @deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
1963 Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
1966 @node @code{GIMPLE_RETURN}
1967 @subsection @code{GIMPLE_RETURN}
1968 @cindex @code{GIMPLE_RETURN}
1970 @deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
1971 Build a @code{GIMPLE_RETURN} statement whose return value is retval.
1974 @deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
1975 Return the return value for @code{GIMPLE_RETURN} @code{G}.
1978 @deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
1979 Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
1982 @node @code{GIMPLE_SWITCH}
1983 @subsection @code{GIMPLE_SWITCH}
1984 @cindex @code{GIMPLE_SWITCH}
1986 @deftypefn {GIMPLE function} gimple gimple_build_switch ( nlabels, tree index, tree default_label, ...)
1987 Build a @code{GIMPLE_SWITCH} statement. @code{NLABELS} are the number of
1988 labels excluding the default label. The default label is passed
1989 in @code{DEFAULT_LABEL}. The rest of the arguments are trees
1990 representing the labels. Each label is a tree of code
1991 @code{CASE_LABEL_EXPR}.
1994 @deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree default_label, @code{VEC}(tree,heap) *args)
1995 This function is an alternate way of building @code{GIMPLE_SWITCH}
1996 statements. @code{INDEX} and @code{DEFAULT_LABEL} are as in
1997 gimple_build_switch. @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees
1998 that contain the labels.
2001 @deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
2002 Return the number of labels associated with the switch statement
2006 @deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, unsigned nlabels)
2007 Set @code{NLABELS} to be the number of labels for the switch statement
2011 @deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
2012 Return the index variable used by the switch statement @code{G}.
2015 @deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
2016 Set @code{INDEX} to be the index variable for switch statement @code{G}.
2019 @deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
2020 Return the label numbered @code{INDEX}. The default label is 0, followed
2021 by any labels in a switch statement.
2024 @deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned index, tree label)
2025 Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
2029 @deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
2030 Return the default label for a switch statement.
2033 @deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, tree label)
2034 Set the default label for a switch statement.
2038 @node @code{GIMPLE_TRY}
2039 @subsection @code{GIMPLE_TRY}
2040 @cindex @code{GIMPLE_TRY}
2042 @deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, gimple_seq cleanup, unsigned int kind)
2043 Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the
2044 expression to evaluate. @code{CLEANUP} is a sequence of statements to
2045 run at clean-up time. @code{KIND} is the enumeration value
2046 @code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
2047 or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
2051 @deftypefn {GIMPLE function} enum gimple_try_flags gimple_try_kind (gimple g)
2052 Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
2053 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
2056 @deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
2057 Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2060 @deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
2061 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
2065 @deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
2066 Return the sequence of statements used as the cleanup body for
2067 @code{GIMPLE_TRY} @code{G}.
2070 @deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
2071 Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2074 @deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
2075 Set @code{EVAL} to be the sequence of statements to use as the body for
2076 @code{GIMPLE_TRY} @code{G}.
2079 @deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
2080 Set @code{CLEANUP} to be the sequence of statements to use as the
2081 cleanup body for @code{GIMPLE_TRY} @code{G}.
2084 @node @code{GIMPLE_WITH_CLEANUP_EXPR}
2085 @subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
2086 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
2088 @deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
2089 Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement. @code{CLEANUP} is the
2090 clean-up expression.
2093 @deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
2094 Return the cleanup sequence for cleanup statement @code{G}.
2097 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
2098 Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
2101 @deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
2102 Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2105 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
2106 Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2110 @node GIMPLE sequences
2111 @section GIMPLE sequences
2112 @cindex GIMPLE sequences
2114 GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
2115 used in @code{GENERIC}. They are used to chain statements together, and
2116 when used in conjunction with sequence iterators, provide a
2117 framework for iterating through statements.
2119 GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
2120 commonly passed by reference to functions dealing with sequences.
2121 The type for a sequence pointer is @code{gimple_seq} which is the same
2122 as struct @code{gimple_sequence} *. When declaring a local sequence,
2123 you can define a local variable of type struct @code{gimple_sequence}.
2124 When declaring a sequence allocated on the garbage collected
2125 heap, use the function @code{gimple_seq_alloc} documented below.
2127 There are convenience functions for iterating through sequences
2128 in the section entitled Sequence Iterators.
2130 Below is a list of functions to manipulate and query sequences.
2132 @deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
2133 Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
2134 not @code{NULL}. If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
2137 @deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
2138 Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
2139 @code{NULL}. If *@code{DEST} is @code{NULL}, allocate a new sequence before
2143 @deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
2144 Perform a deep copy of sequence @code{SRC} and return the result.
2147 @deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
2148 Reverse the order of the statements in the sequence @code{SEQ}. Return
2152 @deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
2153 Return the first statement in sequence @code{S}.
2156 @deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
2157 Return the last statement in sequence @code{S}.
2160 @deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
2161 Set the last statement in sequence @code{S} to the statement in @code{LAST}.
2164 @deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
2165 Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
2168 @deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
2169 Initialize sequence @code{S} to an empty sequence.
2172 @deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
2173 Allocate a new sequence in the garbage collected store and return
2177 @deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
2178 Copy the sequence @code{SRC} into the sequence @code{DEST}.
2181 @deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
2182 Return true if the sequence @code{S} is empty.
2185 @deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
2186 Returns the sequence of statements in @code{BB}.
2189 @deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
2190 Sets the sequence of statements in @code{BB} to @code{SEQ}.
2193 @deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
2194 Determine whether @code{SEQ} contains exactly one statement.
2197 @node Sequence iterators
2198 @section Sequence iterators
2199 @cindex Sequence iterators
2201 Sequence iterators are convenience constructs for iterating
2202 through statements in a sequence. Given a sequence @code{SEQ}, here is
2203 a typical use of gimple sequence iterators:
2206 gimple_stmt_iterator gsi;
2208 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
2210 gimple g = gsi_stmt (gsi);
2211 /* Do something with gimple statement @code{G}. */
2215 Backward iterations are possible:
2218 for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
2221 Forward and backward iterations on basic blocks are possible with
2222 @code{gsi_start_bb} and @code{gsi_last_bb}.
2224 In the documentation below we sometimes refer to enum
2225 @code{gsi_iterator_update}. The valid options for this enumeration are:
2228 @item @code{GSI_NEW_STMT}
2229 Only valid when a single statement is added. Move the iterator to it.
2231 @item @code{GSI_SAME_STMT}
2232 Leave the iterator at the same statement.
2234 @item @code{GSI_CONTINUE_LINKING}
2235 Move iterator to whatever position is suitable for linking other
2236 statements in the same direction.
2239 Below is a list of the functions used to manipulate and use
2240 statement iterators.
2242 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
2243 Return a new iterator pointing to the sequence @code{SEQ}'s first
2244 statement. If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
2245 Use @code{gsi_start_bb} instead when the iterator needs to always have
2246 the correct basic block set.
2249 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
2250 Return a new iterator pointing to the first statement in basic
2254 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
2255 Return a new iterator initially pointing to the last statement of
2256 sequence @code{SEQ}. If @code{SEQ} is empty, the iterator's basic block is
2257 @code{NULL}. Use @code{gsi_last_bb} instead when the iterator needs to always
2258 have the correct basic block set.
2261 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
2262 Return a new iterator pointing to the last statement in basic
2266 @deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
2267 Return @code{TRUE} if at the end of @code{I}.
2270 @deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
2271 Return @code{TRUE} if we're one statement before the end of @code{I}.
2274 @deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
2275 Advance the iterator to the next gimple statement.
2278 @deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
2279 Advance the iterator to the previous gimple statement.
2282 @deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
2283 Return the current stmt.
2286 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb)
2287 Return a block statement iterator that points to the first
2288 non-label statement in block @code{BB}.
2291 @deftypefn {GIMPLE function} gimple *gsi_stmt_ptr (gimple_stmt_iterator *i)
2292 Return a pointer to the current stmt.
2295 @deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
2296 Return the basic block associated with this iterator.
2299 @deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
2300 Return the sequence associated with this iterator.
2303 @deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
2304 Remove the current stmt from the sequence. The iterator is
2305 updated to point to the next statement. When @code{REMOVE_EH_INFO} is
2306 true we remove the statement pointed to by iterator @code{I} from the @code{EH}
2307 tables. Otherwise we do not modify the @code{EH} tables. Generally,
2308 @code{REMOVE_EH_INFO} should be true when the statement is going to be
2309 removed from the @code{IL} and not reinserted elsewhere.
2312 @deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2313 Links the sequence of statements @code{SEQ} before the statement pointed
2314 by iterator @code{I}. @code{MODE} indicates what to do with the iterator
2315 after insertion (see @code{enum gsi_iterator_update} above).
2318 @deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
2319 Links statement @code{G} before the statement pointed-to by iterator @code{I}.
2320 Updates iterator @code{I} according to @code{MODE}.
2323 @deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2324 Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
2325 @code{MODE} is as in @code{gsi_insert_after}.
2328 @deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
2329 Links statement @code{G} after the statement pointed-to by iterator @code{I}.
2330 @code{MODE} is as in @code{gsi_insert_after}.
2333 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
2334 Move all statements in the sequence after @code{I} to a new sequence.
2335 Return this new sequence.
2338 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
2339 Move all statements in the sequence before @code{I} to a new sequence.
2340 Return this new sequence.
2343 @deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, gimple stmt, bool update_eh_info)
2344 Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO}
2345 is true, the exception handling information of the original
2346 statement is moved to the new statement.
2349 @deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
2350 Insert statement @code{STMT} before the statement pointed-to by iterator
2351 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2352 specifies how to update iterator @code{I} after insertion (see enum
2353 @code{gsi_iterator_update}).
2356 @deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2357 Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
2360 @deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, gimple stmt, enum gsi_iterator_update mode)
2361 Insert statement @code{STMT} after the statement pointed-to by iterator
2362 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2363 specifies how to update iterator @code{I} after insertion (see enum
2364 @code{gsi_iterator_update}).
2367 @deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2368 Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
2371 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
2372 Finds iterator for @code{STMT}.
2375 @deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
2376 Move the statement at @code{FROM} so it comes right after the statement
2380 @deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
2381 Move the statement at @code{FROM} so it comes right before the statement
2385 @deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
2386 Move the statement at @code{FROM} to the end of basic block @code{BB}.
2389 @deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
2390 Add @code{STMT} to the pending list of edge @code{E}. No actual insertion is
2391 made until a call to @code{gsi_commit_edge_inserts}() is made.
2394 @deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
2395 Add the sequence of statements in @code{SEQ} to the pending list of edge
2396 @code{E}. No actual insertion is made until a call to
2397 @code{gsi_commit_edge_inserts}() is made.
2400 @deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
2401 Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}. If a new
2402 block has to be created, it is returned.
2405 @deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
2406 Commit insertions pending at edge @code{E}. If a new block is created,
2407 set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
2410 @deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
2411 This routine will commit all pending edge insertions, creating
2412 any new basic blocks which are necessary.
2416 @node Adding a new GIMPLE statement code
2417 @section Adding a new GIMPLE statement code
2418 @cindex Adding a new GIMPLE statement code
2420 The first step in adding a new GIMPLE statement code, is
2421 modifying the file @code{gimple.def}, which contains all the GIMPLE
2422 codes. Then you must add a corresponding structure, and an entry
2423 in @code{union gimple_statement_d}, both of which are located in
2424 @code{gimple.h}. This in turn, will require you to add a corresponding
2425 @code{GTY} tag in @code{gsstruct.def}, and code to handle this tag in
2426 @code{gss_for_code} which is located in @code{gimple.c}.
2428 In order for the garbage collector to know the size of the
2429 structure you created in @code{gimple.h}, you need to add a case to
2430 handle your new GIMPLE statement in @code{gimple_size} which is located
2433 You will probably want to create a function to build the new
2434 gimple statement in @code{gimple.c}. The function should be called
2435 @code{gimple_build_<@code{NEW_TUPLE_NAME}>}, and should return the new tuple
2438 If your new statement requires accessors for any members or
2439 operands it may have, put simple inline accessors in
2440 @code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
2441 corresponding prototype in @code{gimple.h}.
2444 @node Statement and operand traversals
2445 @section Statement and operand traversals
2446 @cindex Statement and operand traversals
2448 There are two functions available for walking statements and
2449 sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
2450 accordingly, and a third function for walking the operands in a
2451 statement: @code{walk_gimple_op}.
2453 @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)
2454 This function is used to walk the current statement in @code{GSI},
2455 optionally using traversal state stored in @code{WI}. If @code{WI} is @code{NULL}, no
2456 state is kept during the traversal.
2458 The callback @code{CALLBACK_STMT} is called. If @code{CALLBACK_STMT} returns
2459 true, it means that the callback function has handled all the
2460 operands of the statement and it is not necessary to walk its
2463 If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
2464 called on each operand of the statement via @code{walk_gimple_op}. If
2465 @code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
2466 operands are not scanned.
2468 The return value is that returned by the last call to
2469 @code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
2473 @deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2474 Use this function to walk the operands of statement @code{STMT}. Every
2475 operand is walked via @code{walk_tree} with optional state information
2478 @code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
2479 Additional parameters to @code{walk_tree} must be stored in @code{WI}. For
2480 each operand @code{OP}, @code{walk_tree} is called as:
2483 walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{WI}- @code{PSET})
2486 If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
2487 operands are not scanned. The return value is that returned by
2488 the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
2493 @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)
2494 This function walks all the statements in the sequence @code{SEQ}
2495 calling @code{walk_gimple_stmt} on each one. @code{WI} is as in
2496 @code{walk_gimple_stmt}. If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
2497 is stopped and the value returned. Otherwise, all the statements
2498 are walked and @code{NULL_TREE} returned.