1 @c Copyright (C) 2008-2023 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 * Class hierarchy of GIMPLE statements::
74 * GIMPLE instruction set::
75 * GIMPLE Exception Handling::
78 * Manipulating GIMPLE statements::
79 * Tuple specific accessors::
81 * Sequence iterators::
82 * Adding a new GIMPLE statement code::
83 * Statement and operand traversals::
86 @node Tuple representation
87 @section Tuple representation
90 GIMPLE instructions are tuples of variable size divided in two
91 groups: a header describing the instruction and its locations,
92 and a variable length body with all the operands. Tuples are
93 organized into a hierarchy with 3 main classes of tuples.
95 @subsection @code{gimple} (gsbase)
98 This is the root of the hierarchy, it holds basic information
99 needed by most GIMPLE statements. There are some fields that
100 may not be relevant to every GIMPLE statement, but those were
101 moved into the base structure to take advantage of holes left by
102 other fields (thus making the structure more compact). The
103 structure takes 4 words (32 bytes) on 64 bit hosts:
105 @multitable {@code{references_memory_p}} {Size (bits)}
106 @item Field @tab Size (bits)
107 @item @code{code} @tab 8
108 @item @code{subcode} @tab 16
109 @item @code{no_warning} @tab 1
110 @item @code{visited} @tab 1
111 @item @code{nontemporal_move} @tab 1
112 @item @code{plf} @tab 2
113 @item @code{modified} @tab 1
114 @item @code{has_volatile_ops} @tab 1
115 @item @code{references_memory_p} @tab 1
116 @item @code{uid} @tab 32
117 @item @code{location} @tab 32
118 @item @code{num_ops} @tab 32
119 @item @code{bb} @tab 64
120 @item @code{block} @tab 63
121 @item Total size @tab 32 bytes
126 Main identifier for a GIMPLE instruction.
129 Used to distinguish different variants of the same basic
130 instruction or provide flags applicable to a given code. The
131 @code{subcode} flags field has different uses depending on the code of
132 the instruction, but mostly it distinguishes instructions of the
133 same family. The most prominent use of this field is in
134 assignments, where subcode indicates the operation done on the
135 RHS of the assignment. For example, a = b + c is encoded as
136 @code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
138 @item @code{no_warning}
139 Bitflag to indicate whether a warning has already been issued on
143 General purpose ``visited'' marker. Set and cleared by each pass
146 @item @code{nontemporal_move}
147 Bitflag used in assignments that represent non-temporal moves.
148 Although this bitflag is only used in assignments, it was moved
149 into the base to take advantage of the bit holes left by the
153 Pass Local Flags. This 2-bit mask can be used as general purpose
154 markers by any pass. Passes are responsible for clearing and
155 setting these two flags accordingly.
157 @item @code{modified}
158 Bitflag to indicate whether the statement has been modified.
159 Used mainly by the operand scanner to determine when to re-scan a
160 statement for operands.
162 @item @code{has_volatile_ops}
163 Bitflag to indicate whether this statement contains operands that
164 have been marked volatile.
166 @item @code{references_memory_p}
167 Bitflag to indicate whether this statement contains memory
168 references (i.e., its operands are either global variables, or
169 pointer dereferences or anything that must reside in memory).
172 This is an unsigned integer used by passes that want to assign
173 IDs to every statement. These IDs must be assigned and used by
176 @item @code{location}
177 This is a @code{location_t} identifier to specify source code
178 location for this statement. It is inherited from the front
182 Number of operands that this statement has. This specifies the
183 size of the operand vector embedded in the tuple. Only used in
184 some tuples, but it is declared in the base tuple to take
185 advantage of the 32-bit hole left by the previous fields.
188 Basic block holding the instruction.
191 Lexical block holding this statement. Also used for debug
192 information generation.
195 @subsection @code{gimple_statement_with_ops}
196 @cindex gimple_statement_with_ops
198 This tuple is actually split in two:
199 @code{gimple_statement_with_ops_base} and
200 @code{gimple_statement_with_ops}. This is needed to accommodate the
201 way the operand vector is allocated. The operand vector is
202 defined to be an array of 1 element. So, to allocate a dynamic
203 number of operands, the memory allocator (@code{gimple_alloc}) simply
204 allocates enough memory to hold the structure itself plus @code{N
205 - 1} operands which run ``off the end'' of the structure. For
206 example, to allocate space for a tuple with 3 operands,
207 @code{gimple_alloc} reserves @code{sizeof (struct
208 gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
210 On the other hand, several fields in this tuple need to be shared
211 with the @code{gimple_statement_with_memory_ops} tuple. So, these
212 common fields are placed in @code{gimple_statement_with_ops_base} which
213 is then inherited from the other two tuples.
216 @multitable {@code{def_ops}} {48 + 8 * @code{num_ops} bytes}
217 @item @code{gsbase} @tab 256
218 @item @code{def_ops} @tab 64
219 @item @code{use_ops} @tab 64
220 @item @code{op} @tab @code{num_ops} * 64
221 @item Total size @tab 48 + 8 * @code{num_ops} bytes
226 Inherited from @code{struct gimple}.
229 Array of pointers into the operand array indicating all the slots that
230 contain a variable written-to by the statement. This array is
231 also used for immediate use chaining. Note that it would be
232 possible to not rely on this array, but the changes required to
233 implement this are pretty invasive.
236 Similar to @code{def_ops} but for variables read by the statement.
239 Array of trees with @code{num_ops} slots.
242 @subsection @code{gimple_statement_with_memory_ops}
244 This tuple is essentially identical to @code{gimple_statement_with_ops},
245 except that it contains 4 additional fields to hold vectors
246 related memory stores and loads. Similar to the previous case,
247 the structure is split in two to accommodate for the operand
248 vector (@code{gimple_statement_with_memory_ops_base} and
249 @code{gimple_statement_with_memory_ops}).
252 @multitable {@code{vdef_ops}} {80 + 8 * @code{num_ops} bytes}
253 @item Field @tab Size (bits)
254 @item @code{gsbase} @tab 256
255 @item @code{def_ops} @tab 64
256 @item @code{use_ops} @tab 64
257 @item @code{vdef_ops} @tab 64
258 @item @code{vuse_ops} @tab 64
259 @item @code{stores} @tab 64
260 @item @code{loads} @tab 64
261 @item @code{op} @tab @code{num_ops} * 64
262 @item Total size @tab 80 + 8 * @code{num_ops} bytes
266 @item @code{vdef_ops}
267 Similar to @code{def_ops} but for @code{VDEF} operators. There is
268 one entry per memory symbol written by this statement. This is
269 used to maintain the memory SSA use-def and def-def chains.
271 @item @code{vuse_ops}
272 Similar to @code{use_ops} but for @code{VUSE} operators. There is
273 one entry per memory symbol loaded by this statement. This is
274 used to maintain the memory SSA use-def chains.
277 Bitset with all the UIDs for the symbols written-to by the
278 statement. This is different than @code{vdef_ops} in that all the
279 affected symbols are mentioned in this set. If memory
280 partitioning is enabled, the @code{vdef_ops} vector will refer to memory
281 partitions. Furthermore, no SSA information is stored in this
285 Similar to @code{stores}, but for memory loads. (Note that there
286 is some amount of redundancy here, it should be possible to
287 reduce memory utilization further by removing these sets).
290 All the other tuples are defined in terms of these three basic
291 ones. Each tuple will add some fields.
294 @node Class hierarchy of GIMPLE statements
295 @section Class hierarchy of GIMPLE statements
296 @cindex GIMPLE class hierarchy
298 The following diagram shows the C++ inheritance hierarchy of statement
299 kinds, along with their relationships to @code{GSS_} values (layouts) and
300 @code{GIMPLE_} values (codes):
305 | used for 4 codes: GIMPLE_ERROR_MARK
307 | GIMPLE_OMP_SECTIONS_SWITCH
310 + gimple_statement_with_ops_base
313 | + gimple_statement_with_ops
314 | | | layout: GSS_WITH_OPS
317 | | | code: GIMPLE_COND
320 | | | code: GIMPLE_DEBUG
323 | | | code: GIMPLE_GOTO
326 | | | code: GIMPLE_LABEL
329 | | code: GIMPLE_SWITCH
331 | + gimple_statement_with_memory_ops_base
332 | | layout: GSS_WITH_MEM_OPS_BASE
334 | + gimple_statement_with_memory_ops
335 | | | layout: GSS_WITH_MEM_OPS
338 | | | code GIMPLE_ASSIGN
341 | | code GIMPLE_RETURN
344 | | layout: GSS_CALL, code: GIMPLE_CALL
347 | | layout: GSS_ASM, code: GIMPLE_ASM
350 | layout: GSS_TRANSACTION, code: GIMPLE_TRANSACTION
352 + gimple_statement_omp
353 | | layout: GSS_OMP. Used for code GIMPLE_OMP_SECTION
356 | | layout: GSS_OMP_CRITICAL, code: GIMPLE_OMP_CRITICAL
359 | | layout: GSS_OMP_FOR, code: GIMPLE_OMP_FOR
361 | + gomp_parallel_layout
362 | | | layout: GSS_OMP_PARALLEL_LAYOUT
364 | | + gimple_statement_omp_taskreg
366 | | | + gomp_parallel
367 | | | | code: GIMPLE_OMP_PARALLEL
370 | | | code: GIMPLE_OMP_TASK
372 | | + gimple_statement_omp_target
373 | | code: GIMPLE_OMP_TARGET
376 | | layout: GSS_OMP_SECTIONS, code: GIMPLE_OMP_SECTIONS
378 | + gimple_statement_omp_single_layout
379 | | layout: GSS_OMP_SINGLE_LAYOUT
382 | | code: GIMPLE_OMP_SINGLE
385 | code: GIMPLE_OMP_TEAMS
388 | layout: GSS_BIND, code: GIMPLE_BIND
391 | layout: GSS_CATCH, code: GIMPLE_CATCH
394 | layout: GSS_EH_FILTER, code: GIMPLE_EH_FILTER
397 | layout: GSS_EH_ELSE, code: GIMPLE_EH_ELSE
400 | layout: GSS_EH_MNT, code: GIMPLE_EH_MUST_NOT_THROW
403 | layout: GSS_PHI, code: GIMPLE_PHI
405 + gimple_statement_eh_ctrl
406 | | layout: GSS_EH_CTRL
409 | | code: GIMPLE_RESX
412 | code: GIMPLE_EH_DISPATCH
415 | layout: GSS_TRY, code: GIMPLE_TRY
417 + gimple_statement_wce
418 | layout: GSS_WCE, code: GIMPLE_WITH_CLEANUP_EXPR
421 | layout: GSS_OMP_CONTINUE, code: GIMPLE_OMP_CONTINUE
424 | layout: GSS_OMP_ATOMIC_LOAD, code: GIMPLE_OMP_ATOMIC_LOAD
426 + gimple_statement_omp_atomic_store_layout
427 | layout: GSS_OMP_ATOMIC_STORE_LAYOUT,
428 | code: GIMPLE_OMP_ATOMIC_STORE
431 | code: GIMPLE_OMP_ATOMIC_STORE
434 code: GIMPLE_OMP_RETURN
438 @node GIMPLE instruction set
439 @section GIMPLE instruction set
440 @cindex GIMPLE instruction set
442 The following table briefly describes the GIMPLE instruction set.
444 @multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE}
445 @item Instruction @tab High GIMPLE @tab Low GIMPLE
446 @item @code{GIMPLE_ASM} @tab x @tab x
447 @item @code{GIMPLE_ASSIGN} @tab x @tab x
448 @item @code{GIMPLE_BIND} @tab x @tab
449 @item @code{GIMPLE_CALL} @tab x @tab x
450 @item @code{GIMPLE_CATCH} @tab x @tab
451 @item @code{GIMPLE_COND} @tab x @tab x
452 @item @code{GIMPLE_DEBUG} @tab x @tab x
453 @item @code{GIMPLE_EH_FILTER} @tab x @tab
454 @item @code{GIMPLE_GOTO} @tab x @tab x
455 @item @code{GIMPLE_LABEL} @tab x @tab x
456 @item @code{GIMPLE_NOP} @tab x @tab x
457 @item @code{GIMPLE_OMP_ATOMIC_LOAD} @tab x @tab x
458 @item @code{GIMPLE_OMP_ATOMIC_STORE} @tab x @tab x
459 @item @code{GIMPLE_OMP_CONTINUE} @tab x @tab x
460 @item @code{GIMPLE_OMP_CRITICAL} @tab x @tab x
461 @item @code{GIMPLE_OMP_FOR} @tab x @tab x
462 @item @code{GIMPLE_OMP_MASTER} @tab x @tab x
463 @item @code{GIMPLE_OMP_ORDERED} @tab x @tab x
464 @item @code{GIMPLE_OMP_PARALLEL} @tab x @tab x
465 @item @code{GIMPLE_OMP_RETURN} @tab x @tab x
466 @item @code{GIMPLE_OMP_SECTION} @tab x @tab x
467 @item @code{GIMPLE_OMP_SECTIONS} @tab x @tab x
468 @item @code{GIMPLE_OMP_SECTIONS_SWITCH} @tab x @tab x
469 @item @code{GIMPLE_OMP_SINGLE} @tab x @tab x
470 @item @code{GIMPLE_PHI} @tab @tab x
471 @item @code{GIMPLE_OMP_STRUCTURED_BLOCK} @tab x @tab
472 @item @code{GIMPLE_RESX} @tab @tab x
473 @item @code{GIMPLE_RETURN} @tab x @tab x
474 @item @code{GIMPLE_SWITCH} @tab x @tab x
475 @item @code{GIMPLE_TRY} @tab x @tab
478 @node GIMPLE Exception Handling
479 @section Exception Handling
480 @cindex GIMPLE Exception Handling
482 Other exception handling constructs are represented using
483 @code{GIMPLE_TRY_CATCH}. @code{GIMPLE_TRY_CATCH} has two operands. The
484 first operand is a sequence of statements to execute. If executing
485 these statements does not throw an exception, then the second operand
486 is ignored. Otherwise, if an exception is thrown, then the second
487 operand of the @code{GIMPLE_TRY_CATCH} is checked. The second
488 operand may have the following forms:
492 @item A sequence of statements to execute. When an exception occurs,
493 these statements are executed, and then the exception is rethrown.
495 @item A sequence of @code{GIMPLE_CATCH} statements. Each
496 @code{GIMPLE_CATCH} has a list of applicable exception types and
497 handler code. If the thrown exception matches one of the caught
498 types, the associated handler code is executed. If the handler
499 code falls off the bottom, execution continues after the original
500 @code{GIMPLE_TRY_CATCH}.
502 @item A @code{GIMPLE_EH_FILTER} statement. This has a list of
503 permitted exception types, and code to handle a match failure. If the
504 thrown exception does not match one of the allowed types, the
505 associated match failure code is executed. If the thrown exception
506 does match, it continues unwinding the stack looking for the next
511 Currently throwing an exception is not directly represented in
512 GIMPLE, since it is implemented by calling a function. At some
513 point in the future we will want to add some way to express that
514 the call will throw an exception of a known type.
516 Just before running the optimizers, the compiler lowers the
517 high-level EH constructs above into a set of @samp{goto}s, magic
518 labels, and EH regions. Continuing to unwind at the end of a
519 cleanup is represented with a @code{GIMPLE_RESX}.
526 When gimplification encounters a subexpression that is too
527 complex, it creates a new temporary variable to hold the value of
528 the subexpression, and adds a new statement to initialize it
529 before the current statement. These special temporaries are known
530 as @samp{expression temporaries}, and are allocated using
531 @code{get_formal_tmp_var}. The compiler tries to always evaluate
532 identical expressions into the same temporary, to simplify
533 elimination of redundant calculations.
535 We can only use expression temporaries when we know that it will
536 not be reevaluated before its value is used, and that it will not
537 be otherwise modified@footnote{These restrictions are derived
538 from those in Morgan 4.8.}. Other temporaries can be allocated
539 using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
541 Currently, an expression like @code{a = b + 5} is not reduced any
542 further. We tried converting it to something like
547 but this bloated the representation for minimal benefit. However, a
548 variable which must live in memory cannot appear in an expression; its
549 value is explicitly loaded into a temporary first. Similarly, storing
550 the value of an expression to a memory variable goes through a
557 In general, expressions in GIMPLE consist of an operation and the
558 appropriate number of simple operands; these operands must either be a
559 GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
560 variable. More complex operands are factored out into temporaries, so
571 The same rule holds for arguments to a @code{GIMPLE_CALL}.
573 The target of an assignment is usually a variable, but can also be a
574 @code{MEM_REF} or a compound lvalue as described below.
577 * Compound Expressions::
579 * Conditional Expressions::
580 * Logical Operators::
583 @node Compound Expressions
584 @subsection Compound Expressions
585 @cindex Compound Expressions
587 The left-hand side of a C comma expression is simply moved into a separate
590 @node Compound Lvalues
591 @subsection Compound Lvalues
592 @cindex Compound Lvalues
594 Currently compound lvalues involving array and structure field references
595 are not broken down; an expression like @code{a.b[2] = 42} is not reduced
596 any further (though complex array subscripts are). This restriction is a
597 workaround for limitations in later optimizers; if we were to convert this
605 alias analysis would not remember that the reference to @code{T1[2]} came
606 by way of @code{a.b}, so it would think that the assignment could alias
607 another member of @code{a}; this broke @code{struct-alias-1.c}. Future
608 optimizer improvements may make this limitation unnecessary.
610 @node Conditional Expressions
611 @subsection Conditional Expressions
612 @cindex Conditional Expressions
614 A C @code{?:} expression is converted into an @code{if} statement with
615 each branch assigning to the same temporary. So,
629 The GIMPLE level if-conversion pass re-introduces @code{?:}
630 expression, if appropriate. It is used to vectorize loops with
631 conditions using vector conditional operations.
633 Note that in GIMPLE, @code{if} statements are represented using
634 @code{GIMPLE_COND}, as described below.
636 @node Logical Operators
637 @subsection Logical Operators
638 @cindex Logical Operators
640 Except when they appear in the condition operand of a
641 @code{GIMPLE_COND}, logical `and' and `or' operators are simplified
642 as follows: @code{a = b && c} becomes
651 Note that @code{T1} in this example cannot be an expression temporary,
652 because it has two different assignments.
654 @subsection Manipulating operands
656 All gimple operands are of type @code{tree}. But only certain
657 types of trees are allowed to be used as operand tuples. Basic
658 validation is controlled by the function
659 @code{get_gimple_rhs_class}, which given a tree code, returns an
660 @code{enum} with the following values of type @code{enum
664 @item @code{GIMPLE_INVALID_RHS}
665 The tree cannot be used as a GIMPLE operand.
667 @item @code{GIMPLE_TERNARY_RHS}
668 The tree is a valid GIMPLE ternary operation.
670 @item @code{GIMPLE_BINARY_RHS}
671 The tree is a valid GIMPLE binary operation.
673 @item @code{GIMPLE_UNARY_RHS}
674 The tree is a valid GIMPLE unary operation.
676 @item @code{GIMPLE_SINGLE_RHS}
677 The tree is a single object, that cannot be split into simpler
678 operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc).
680 This operand class also acts as an escape hatch for tree nodes
681 that may be flattened out into the operand vector, but would need
682 more than two slots on the RHS. For instance, a @code{COND_EXPR}
683 expression of the form @code{(a op b) ? x : y} could be flattened
684 out on the operand vector using 4 slots, but it would also
685 require additional processing to distinguish @code{c = a op b}
686 from @code{c = a op b ? x : y}. In time, these special case tree
687 expressions should be flattened into the operand vector.
690 For tree nodes in the categories @code{GIMPLE_TERNARY_RHS},
691 @code{GIMPLE_BINARY_RHS} and @code{GIMPLE_UNARY_RHS}, they cannot be
692 stored inside tuples directly. They first need to be flattened and
693 separated into individual components. For instance, given the GENERIC
700 its tree representation is:
703 MODIFY_EXPR <VAR_DECL <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>
706 In this case, the GIMPLE form for this statement is logically
707 identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
708 on the RHS of the assignment is not represented as a tree,
709 instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree
710 and flattened into the GIMPLE tuple as follows:
713 GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>
716 @subsection Operand vector allocation
718 The operand vector is stored at the bottom of the three tuple
719 structures that accept operands. This means, that depending on
720 the code of a given statement, its operand vector will be at
721 different offsets from the base of the structure. To access
722 tuple operands use the following accessors
724 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
725 Returns the number of operands in statement G.
728 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
729 Returns operand @code{I} from statement @code{G}.
732 @deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
733 Returns a pointer into the operand vector for statement @code{G}. This
734 is computed using an internal table called @code{gimple_ops_offset_}[].
735 This table is indexed by the gimple code of @code{G}.
737 When the compiler is built, this table is filled-in using the
738 sizes of the structures used by each statement code defined in
739 gimple.def. Since the operand vector is at the bottom of the
740 structure, for a gimple code @code{C} the offset is computed as sizeof
741 (struct-of @code{C}) - sizeof (tree).
743 This mechanism adds one memory indirection to every access when
744 using @code{gimple_op}(), if this becomes a bottleneck, a pass can
745 choose to memoize the result from @code{gimple_ops}() and use that to
749 @subsection Operand validation
751 When adding a new operand to a gimple statement, the operand will
752 be validated according to what each tuple accepts in its operand
753 vector. These predicates are called by the
754 @code{gimple_@var{name}_set_...()}. Each tuple will use one of the
755 following predicates (Note, this list is not exhaustive):
757 @deftypefn {GIMPLE function} bool is_gimple_val (tree t)
758 Returns true if t is a "GIMPLE value", which are all the
759 non-addressable stack variables (variables for which
760 @code{is_gimple_reg} returns true) and constants (expressions for which
761 @code{is_gimple_min_invariant} returns true).
764 @deftypefn {GIMPLE function} bool is_gimple_addressable (tree t)
765 Returns true if t is a symbol or memory reference whose address
769 @deftypefn {GIMPLE function} bool is_gimple_asm_val (tree t)
770 Similar to @code{is_gimple_val} but it also accepts hard registers.
773 @deftypefn {GIMPLE function} bool is_gimple_call_addr (tree t)
774 Return true if t is a valid expression to use as the function
775 called by a @code{GIMPLE_CALL}.
778 @deftypefn {GIMPLE function} bool is_gimple_mem_ref_addr (tree t)
779 Return true if t is a valid expression to use as first operand
780 of a @code{MEM_REF} expression.
783 @deftypefn {GIMPLE function} bool is_gimple_constant (tree t)
784 Return true if t is a valid gimple constant.
787 @deftypefn {GIMPLE function} bool is_gimple_min_invariant (tree t)
788 Return true if t is a valid minimal invariant. This is different
789 from constants, in that the specific value of t may not be known
790 at compile time, but it is known that it doesn't change (e.g.,
791 the address of a function local variable).
794 @deftypefn {GIMPLE function} bool is_gimple_ip_invariant (tree t)
795 Return true if t is an interprocedural invariant. This means that t
796 is a valid invariant in all functions (e.g.@: it can be an address of a
797 global variable but not of a local one).
800 @deftypefn {GIMPLE function} bool is_gimple_ip_invariant_address (tree t)
801 Return true if t is an @code{ADDR_EXPR} that does not change once the
802 program is running (and which is valid in all functions).
806 @subsection Statement validation
808 @deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
809 Return true if the code of g is @code{GIMPLE_ASSIGN}.
812 @deftypefn {GIMPLE function} bool is_gimple_call (gimple g)
813 Return true if the code of g is @code{GIMPLE_CALL}.
816 @deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)
817 Return true if the code of g is @code{GIMPLE_DEBUG}.
820 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple g)
821 Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
825 @deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g)
826 Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
827 expression to a variable.
830 @deftypefn {GIMPLE function} bool is_gimple_omp (gimple g)
831 Return true if g is any of the OpenMP codes.
834 @deftypefn {GIMPLE function} bool gimple_debug_begin_stmt_p (gimple g)
835 Return true if g is a @code{GIMPLE_DEBUG} that marks the beginning of
839 @deftypefn {GIMPLE function} bool gimple_debug_inline_entry_p (gimple g)
840 Return true if g is a @code{GIMPLE_DEBUG} that marks the entry
841 point of an inlined function.
844 @deftypefn {GIMPLE function} bool gimple_debug_nonbind_marker_p (gimple g)
845 Return true if g is a @code{GIMPLE_DEBUG} that marks a program location,
846 without any variable binding.
849 @node Manipulating GIMPLE statements
850 @section Manipulating GIMPLE statements
851 @cindex Manipulating GIMPLE statements
853 This section documents all the functions available to handle each
854 of the GIMPLE instructions.
856 @subsection Common accessors
857 The following are common accessors for gimple statements.
859 @deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
860 Return the code for statement @code{G}.
863 @deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
864 Return the basic block to which statement @code{G} belongs to.
867 @deftypefn {GIMPLE function} tree gimple_block (gimple g)
868 Return the lexical scope block holding statement @code{G}.
871 @deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
872 Return the tree code for the expression computed by @code{STMT}. This
873 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
874 @code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
875 For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
876 For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
877 by the @code{RHS} of the assignment.
880 @deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
881 Set the lexical scope block of @code{G} to @code{BLOCK}.
884 @deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
885 Return locus information for statement @code{G}.
888 @deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
889 Set locus information for statement @code{G}.
892 @deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
893 Return true if @code{G} does not have locus information.
896 @deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
897 Return true if no warnings should be emitted for statement @code{STMT}.
900 @deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
901 Set the visited status on statement @code{STMT} to @code{VISITED_P}.
904 @deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
905 Return the visited status on statement @code{STMT}.
908 @deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
909 Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
912 @deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
913 Return the value of pass local flag @code{PLF} on statement @code{STMT}.
916 @deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
917 Return true if statement @code{G} has register or memory operands.
920 @deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
921 Return true if statement @code{G} has memory operands.
924 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
925 Return the number of operands for statement @code{G}.
928 @deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
929 Return the array of operands for statement @code{G}.
932 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
933 Return operand @code{I} for statement @code{G}.
936 @deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
937 Return a pointer to operand @code{I} for statement @code{G}.
940 @deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
941 Set operand @code{I} of statement @code{G} to @code{OP}.
944 @deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
945 Return the set of symbols that have had their address taken by
949 @deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
950 Return the set of @code{DEF} operands for statement @code{G}.
953 @deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
954 Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
957 @deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
958 Return the set of @code{USE} operands for statement @code{G}.
961 @deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
962 Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
965 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
966 Return the set of @code{VUSE} operands for statement @code{G}.
969 @deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
970 Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
973 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
974 Return the set of @code{VDEF} operands for statement @code{G}.
977 @deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
978 Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
981 @deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
982 Return the set of symbols loaded by statement @code{G}. Each element of
983 the set is the @code{DECL_UID} of the corresponding symbol.
986 @deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
987 Return the set of symbols stored by statement @code{G}. Each element of
988 the set is the @code{DECL_UID} of the corresponding symbol.
991 @deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
992 Return true if statement @code{G} has operands and the modified field
996 @deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
997 Return true if statement @code{STMT} contains volatile operands.
1000 @deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
1001 Return true if statement @code{STMT} contains volatile operands.
1004 @deftypefn {GIMPLE function} void update_stmt (gimple s)
1005 Mark statement @code{S} as modified, and update it.
1008 @deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
1009 Update statement @code{S} if it has been marked modified.
1012 @deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
1013 Return a deep copy of statement @code{STMT}.
1016 @node Tuple specific accessors
1017 @section Tuple specific accessors
1018 @cindex Tuple specific accessors
1021 * @code{GIMPLE_ASM}::
1022 * @code{GIMPLE_ASSIGN}::
1023 * @code{GIMPLE_BIND}::
1024 * @code{GIMPLE_CALL}::
1025 * @code{GIMPLE_CATCH}::
1026 * @code{GIMPLE_COND}::
1027 * @code{GIMPLE_DEBUG}::
1028 * @code{GIMPLE_EH_FILTER}::
1029 * @code{GIMPLE_LABEL}::
1030 * @code{GIMPLE_GOTO}::
1031 * @code{GIMPLE_NOP}::
1032 * @code{GIMPLE_OMP_ATOMIC_LOAD}::
1033 * @code{GIMPLE_OMP_ATOMIC_STORE}::
1034 * @code{GIMPLE_OMP_CONTINUE}::
1035 * @code{GIMPLE_OMP_CRITICAL}::
1036 * @code{GIMPLE_OMP_FOR}::
1037 * @code{GIMPLE_OMP_MASTER}::
1038 * @code{GIMPLE_OMP_ORDERED}::
1039 * @code{GIMPLE_OMP_PARALLEL}::
1040 * @code{GIMPLE_OMP_RETURN}::
1041 * @code{GIMPLE_OMP_SECTION}::
1042 * @code{GIMPLE_OMP_SECTIONS}::
1043 * @code{GIMPLE_OMP_SINGLE}::
1044 * @code{GIMPLE_OMP_STRUCTURED_BLOCK}::
1045 * @code{GIMPLE_PHI}::
1046 * @code{GIMPLE_RESX}::
1047 * @code{GIMPLE_RETURN}::
1048 * @code{GIMPLE_SWITCH}::
1049 * @code{GIMPLE_TRY}::
1050 * @code{GIMPLE_WITH_CLEANUP_EXPR}::
1054 @node @code{GIMPLE_ASM}
1055 @subsection @code{GIMPLE_ASM}
1056 @cindex @code{GIMPLE_ASM}
1058 @deftypefn {GIMPLE function} gasm *gimple_build_asm_vec ( @
1059 const char *string, vec<tree, va_gc> *inputs, @
1060 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers, @
1061 vec<tree, va_gc> *labels)
1062 Build a @code{GIMPLE_ASM} statement. This statement is used for
1063 building in-line assembly constructs. @code{STRING} is the assembly
1064 code. @code{INPUTS}, @code{OUTPUTS}, @code{CLOBBERS} and @code{LABELS}
1065 are the inputs, outputs, clobbered registers and labels.
1068 @deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (const gasm *g)
1069 Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
1072 @deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (const gasm *g)
1073 Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
1076 @deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (const gasm *g)
1077 Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
1080 @deftypefn {GIMPLE function} tree gimple_asm_input_op (const gasm *g, @
1082 Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1085 @deftypefn {GIMPLE function} void gimple_asm_set_input_op (gasm *g, @
1086 unsigned index, tree in_op)
1087 Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1090 @deftypefn {GIMPLE function} tree gimple_asm_output_op (const gasm *g, @
1092 Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1095 @deftypefn {GIMPLE function} void gimple_asm_set_output_op (gasm *g, @
1096 unsigned index, tree out_op)
1097 Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1100 @deftypefn {GIMPLE function} tree gimple_asm_clobber_op (const gasm *g, @
1102 Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1105 @deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gasm *g, @
1106 unsigned index, tree clobber_op)
1107 Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1110 @deftypefn {GIMPLE function} {const char *} gimple_asm_string (const gasm *g)
1111 Return the string representing the assembly instruction in
1112 @code{GIMPLE_ASM} @code{G}.
1115 @deftypefn {GIMPLE function} bool gimple_asm_volatile_p (const gasm *g)
1116 Return true if @code{G} is an asm statement marked volatile.
1119 @deftypefn {GIMPLE function} void gimple_asm_set_volatile (gasm *g, @
1121 Mark asm statement @code{G} as volatile or non-volatile based on
1125 @node @code{GIMPLE_ASSIGN}
1126 @subsection @code{GIMPLE_ASSIGN}
1127 @cindex @code{GIMPLE_ASSIGN}
1129 @deftypefn {GIMPLE function} gassign *gimple_build_assign (tree lhs, tree rhs)
1130 Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue
1131 passed in lhs. The right-hand side can be either a unary or
1132 binary tree expression. The expression tree rhs will be
1133 flattened and its operands assigned to the corresponding operand
1134 slots in the new statement. This function is useful when you
1135 already have a tree expression that you want to convert into a
1136 tuple. However, try to avoid building expression trees for the
1137 sole purpose of calling this function. If you already have the
1138 operands in separate trees, it is better to use
1139 @code{gimple_build_assign} with @code{enum tree_code} argument and separate
1140 arguments for each operand.
1143 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1144 (tree lhs, enum tree_code subcode, tree op1, tree op2, tree op3)
1145 This function is similar to two operand @code{gimple_build_assign},
1146 but is used to build a @code{GIMPLE_ASSIGN} statement when the operands of the
1147 right-hand side of the assignment are already split into
1150 The left-hand side is an lvalue passed in lhs. Subcode is the
1151 @code{tree_code} for the right-hand side of the assignment. Op1, op2 and op3
1155 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1156 (tree lhs, enum tree_code subcode, tree op1, tree op2)
1157 Like the above 5 operand @code{gimple_build_assign}, but with the last
1158 argument @code{NULL} - this overload should not be used for
1159 @code{GIMPLE_TERNARY_RHS} assignments.
1162 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1163 (tree lhs, enum tree_code subcode, tree op1)
1164 Like the above 4 operand @code{gimple_build_assign}, but with the last
1165 argument @code{NULL} - this overload should be used only for
1166 @code{GIMPLE_UNARY_RHS} and @code{GIMPLE_SINGLE_RHS} assignments.
1169 @deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
1170 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
1174 @code{DST}/@code{SRC} are the destination and source respectively. You can
1175 pass ungimplified trees in @code{DST} or @code{SRC}, in which
1176 case they will be converted to a gimple operand if necessary.
1178 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
1180 @deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
1181 Return the code of the expression computed on the @code{RHS} of
1182 assignment statement @code{G}.
1186 @deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
1187 Return the gimple rhs class of the code for the expression
1188 computed on the rhs of assignment statement @code{G}. This will never
1189 return @code{GIMPLE_INVALID_RHS}.
1192 @deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
1193 Return the @code{LHS} of assignment statement @code{G}.
1196 @deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
1197 Return a pointer to the @code{LHS} of assignment statement @code{G}.
1200 @deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
1201 Return the first operand on the @code{RHS} of assignment statement @code{G}.
1204 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
1205 Return the address of the first operand on the @code{RHS} of assignment
1209 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
1210 Return the second operand on the @code{RHS} of assignment statement @code{G}.
1213 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
1214 Return the address of the second operand on the @code{RHS} of assignment
1218 @deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
1219 Return the third operand on the @code{RHS} of assignment statement @code{G}.
1222 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
1223 Return the address of the third operand on the @code{RHS} of assignment
1227 @deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
1228 Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
1231 @deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
1232 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
1236 @deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
1237 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
1241 @deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
1242 Set @code{RHS} to be the third operand on the @code{RHS} of assignment
1246 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple s)
1247 Return true if @code{S} is a type-cast assignment.
1251 @node @code{GIMPLE_BIND}
1252 @subsection @code{GIMPLE_BIND}
1253 @cindex @code{GIMPLE_BIND}
1255 @deftypefn {GIMPLE function} gbind *gimple_build_bind (tree vars, @
1257 Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
1258 and a body of statements in sequence @code{BODY}.
1261 @deftypefn {GIMPLE function} tree gimple_bind_vars (const gbind *g)
1262 Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
1265 @deftypefn {GIMPLE function} void gimple_bind_set_vars (gbind *g, tree vars)
1266 Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
1270 @deftypefn {GIMPLE function} void gimple_bind_append_vars (gbind *g, tree vars)
1271 Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
1275 @deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gbind *g)
1276 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
1280 @deftypefn {GIMPLE function} void gimple_bind_set_body (gbind *g, @
1282 Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
1285 @deftypefn {GIMPLE function} void gimple_bind_add_stmt (gbind *gs, gimple stmt)
1286 Append a statement to the end of a @code{GIMPLE_BIND}'s body.
1289 @deftypefn {GIMPLE function} void gimple_bind_add_seq (gbind *gs, @
1291 Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
1295 @deftypefn {GIMPLE function} tree gimple_bind_block (const gbind *g)
1296 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
1297 @code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
1300 @deftypefn {GIMPLE function} void gimple_bind_set_block (gbind *g, tree block)
1301 Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
1306 @node @code{GIMPLE_CALL}
1307 @subsection @code{GIMPLE_CALL}
1308 @cindex @code{GIMPLE_CALL}
1310 @deftypefn {GIMPLE function} gcall *gimple_build_call (tree fn, @
1311 unsigned nargs, ...)
1312 Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN}
1313 must be either a @code{FUNCTION_DECL} or a gimple call address as
1314 determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of
1315 arguments. The rest of the arguments follow the argument @code{NARGS},
1316 and must be trees that are valid as rvalues in gimple (i.e., each
1317 operand is validated with @code{is_gimple_operand}).
1321 @deftypefn {GIMPLE function} gcall *gimple_build_call_from_tree (tree call_expr, @
1323 Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments
1324 and the function are taken from the expression directly. The type of the
1325 @code{GIMPLE_CALL} is set from the second parameter passed by a caller.
1326 This routine assumes that @code{call_expr} is already in GIMPLE form.
1327 That is, its operands are GIMPLE values and the function call needs no further
1328 simplification. All the call flags in @code{call_expr} are copied over
1329 to the new @code{GIMPLE_CALL}.
1332 @deftypefn {GIMPLE function} gcall *gimple_build_call_vec (tree fn, @
1333 @code{vec<tree>} args)
1334 Identical to @code{gimple_build_call} but the arguments are stored in a
1338 @deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
1339 Return the @code{LHS} of call statement @code{G}.
1342 @deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
1343 Return a pointer to the @code{LHS} of call statement @code{G}.
1346 @deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
1347 Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
1350 @deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
1351 Return the tree node representing the function called by call
1355 @deftypefn {GIMPLE function} void gimple_call_set_fn (gcall *g, tree fn)
1356 Set @code{FN} to be the function called by call statement @code{G}. This has
1357 to be a gimple value specifying the address of the called
1361 @deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
1362 If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
1363 Otherwise return @code{NULL}. This function is analogous to
1364 @code{get_callee_fndecl} in @code{GENERIC}.
1367 @deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
1368 Set the called function to @code{FNDECL}.
1371 @deftypefn {GIMPLE function} tree gimple_call_return_type (const gcall *g)
1372 Return the type returned by call statement @code{G}.
1375 @deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
1376 Return the static chain for call statement @code{G}.
1379 @deftypefn {GIMPLE function} void gimple_call_set_chain (gcall *g, tree chain)
1380 Set @code{CHAIN} to be the static chain for call statement @code{G}.
1383 @deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
1384 Return the number of arguments used by call statement @code{G}.
1387 @deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
1388 Return the argument at position @code{INDEX} for call statement @code{G}. The
1389 first argument is 0.
1392 @deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
1393 Return a pointer to the argument at position @code{INDEX} for call
1397 @deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
1398 Set @code{ARG} to be the argument at position @code{INDEX} for call statement
1402 @deftypefn {GIMPLE function} void gimple_call_set_tail (gcall *s)
1403 Mark call statement @code{S} as being a tail call (i.e., a call just
1404 before the exit of a function). These calls are candidate for
1405 tail call optimization.
1408 @deftypefn {GIMPLE function} bool gimple_call_tail_p (gcall *s)
1409 Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
1412 @deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
1413 Return true if @code{S} is a noreturn call.
1416 @deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gcall *stmt, @
1417 bitmap args_to_skip)
1418 Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
1419 in the positions marked by the set @code{ARGS_TO_SKIP}.
1423 @node @code{GIMPLE_CATCH}
1424 @subsection @code{GIMPLE_CATCH}
1425 @cindex @code{GIMPLE_CATCH}
1427 @deftypefn {GIMPLE function} gcatch *gimple_build_catch (tree types, @
1429 Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this
1430 catch handles. @code{HANDLER} is a sequence of statements with the code
1434 @deftypefn {GIMPLE function} tree gimple_catch_types (const gcatch *g)
1435 Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
1438 @deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gcatch *g)
1439 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
1443 @deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gcatch *g)
1444 Return the GIMPLE sequence representing the body of the handler
1445 of @code{GIMPLE_CATCH} statement @code{G}.
1448 @deftypefn {GIMPLE function} void gimple_catch_set_types (gcatch *g, tree t)
1449 Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
1452 @deftypefn {GIMPLE function} void gimple_catch_set_handler (gcatch *g, @
1454 Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
1458 @node @code{GIMPLE_COND}
1459 @subsection @code{GIMPLE_COND}
1460 @cindex @code{GIMPLE_COND}
1462 @deftypefn {GIMPLE function} gcond *gimple_build_cond ( @
1463 enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
1464 Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares
1465 @code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
1466 the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
1467 @code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
1468 @code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
1472 @deftypefn {GIMPLE function} gcond *gimple_build_cond_from_tree (tree cond, @
1473 tree t_label, tree f_label)
1474 Build a @code{GIMPLE_COND} statement from the conditional expression
1475 tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
1478 @deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
1479 Return the code of the predicate computed by conditional
1483 @deftypefn {GIMPLE function} void gimple_cond_set_code (gcond *g, @
1484 enum tree_code code)
1485 Set @code{CODE} to be the predicate code for the conditional statement
1489 @deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
1490 Return the @code{LHS} of the predicate computed by conditional statement
1494 @deftypefn {GIMPLE function} void gimple_cond_set_lhs (gcond *g, tree lhs)
1495 Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
1496 conditional statement @code{G}.
1499 @deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
1500 Return the @code{RHS} operand of the predicate computed by conditional
1504 @deftypefn {GIMPLE function} void gimple_cond_set_rhs (gcond *g, tree rhs)
1505 Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
1506 conditional statement @code{G}.
1509 @deftypefn {GIMPLE function} tree gimple_cond_true_label (const gcond *g)
1510 Return the label used by conditional statement @code{G} when its
1511 predicate evaluates to true.
1514 @deftypefn {GIMPLE function} void gimple_cond_set_true_label (gcond *g, tree label)
1515 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1516 its predicate evaluates to true.
1519 @deftypefn {GIMPLE function} void gimple_cond_set_false_label (gcond *g, tree label)
1520 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1521 its predicate evaluates to false.
1524 @deftypefn {GIMPLE function} tree gimple_cond_false_label (const gcond *g)
1525 Return the label used by conditional statement @code{G} when its
1526 predicate evaluates to false.
1529 @deftypefn {GIMPLE function} void gimple_cond_make_false (gcond *g)
1530 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
1533 @deftypefn {GIMPLE function} void gimple_cond_make_true (gcond *g)
1534 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
1537 @node @code{GIMPLE_DEBUG}
1538 @subsection @code{GIMPLE_DEBUG}
1539 @cindex @code{GIMPLE_DEBUG}
1540 @cindex @code{GIMPLE_DEBUG_BIND}
1541 @cindex @code{GIMPLE_DEBUG_BEGIN_STMT}
1542 @cindex @code{GIMPLE_DEBUG_INLINE_ENTRY}
1544 @deftypefn {GIMPLE function} gdebug *gimple_build_debug_bind (tree var, @
1545 tree value, gimple stmt)
1546 Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND}
1547 @code{subcode}. The effect of this statement is to tell debug
1548 information generation machinery that the value of user variable
1549 @code{var} is given by @code{value} at that point, and to remain with
1550 that value until @code{var} runs out of scope, a
1551 dynamically-subsequent debug bind statement overrides the binding, or
1552 conflicting values reach a control flow merge point. Even if
1553 components of the @code{value} expression change afterwards, the
1554 variable is supposed to retain the same value, though not necessarily
1557 It is expected that @code{var} be most often a tree for automatic user
1558 variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the
1559 requirements for gimple registers, but it may also be a tree for a
1560 scalarized component of a user variable (@code{ARRAY_REF},
1561 @code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}).
1563 As for @code{value}, it can be an arbitrary tree expression, but it is
1564 recommended that it be in a suitable form for a gimple assignment
1565 @code{RHS}. It is not expected that user variables that could appear
1566 as @code{var} ever appear in @code{value}, because in the latter we'd
1567 have their @code{SSA_NAME}s instead, but even if they were not in SSA
1568 form, user variables appearing in @code{value} are to be regarded as
1569 part of the executable code space, whereas those in @code{var} are to
1570 be regarded as part of the source code space. There is no way to
1571 refer to the value bound to a user variable within a @code{value}
1574 If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
1575 generation machinery is informed that the variable @code{var} is
1576 unbound, i.e., that its value is indeterminate, which sometimes means
1577 it is really unavailable, and other times that the compiler could not
1580 Block and location information for the newly-created stmt are
1581 taken from @code{stmt}, if given.
1584 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
1585 Return the user variable @var{var} that is bound at @code{stmt}.
1588 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
1589 Return the value expression that is bound to a user variable at
1593 @deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt)
1594 Return a pointer to the value expression that is bound to a user
1595 variable at @code{stmt}.
1598 @deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
1599 Modify the user variable bound at @code{stmt} to @var{var}.
1602 @deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
1603 Modify the value bound to the user variable bound at @code{stmt} to
1607 @deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
1608 Modify the value bound to the user variable bound at @code{stmt} so
1609 that the variable becomes unbound.
1612 @deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
1613 Return @code{TRUE} if @code{stmt} binds a user variable to a value,
1614 and @code{FALSE} if it unbinds the variable.
1617 @deftypefn {GIMPLE function} gimple gimple_build_debug_begin_stmt (tree block, location_t location)
1618 Build a @code{GIMPLE_DEBUG} statement with
1619 @code{GIMPLE_DEBUG_BEGIN_STMT} @code{subcode}. The effect of this
1620 statement is to tell debug information generation machinery that the
1621 user statement at the given @code{location} and @code{block} starts at
1622 the point at which the statement is inserted. The intent is that side
1623 effects (e.g.@: variable bindings) of all prior user statements are
1624 observable, and that none of the side effects of subsequent user
1628 @deftypefn {GIMPLE function} gimple gimple_build_debug_inline_entry (tree block, location_t location)
1629 Build a @code{GIMPLE_DEBUG} statement with
1630 @code{GIMPLE_DEBUG_INLINE_ENTRY} @code{subcode}. The effect of this
1631 statement is to tell debug information generation machinery that a
1632 function call at @code{location} underwent inline substitution, that
1633 @code{block} is the enclosing lexical block created for the
1634 substitution, and that at the point of the program in which the stmt is
1635 inserted, all parameters for the inlined function are bound to the
1636 respective arguments, and none of the side effects of its stmts are
1640 @node @code{GIMPLE_EH_FILTER}
1641 @subsection @code{GIMPLE_EH_FILTER}
1642 @cindex @code{GIMPLE_EH_FILTER}
1644 @deftypefn {GIMPLE function} geh_filter *gimple_build_eh_filter (tree types, @
1646 Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's
1647 types. @code{FAILURE} is a sequence with the filter's failure action.
1650 @deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
1651 Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
1654 @deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
1655 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
1659 @deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
1660 Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
1664 @deftypefn {GIMPLE function} void gimple_eh_filter_set_types (geh_filter *g, @
1666 Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
1669 @deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (geh_filter *g, @
1671 Set @code{FAILURE} to be the sequence of statements to execute on
1672 failure for @code{GIMPLE_EH_FILTER} @code{G}.
1675 @deftypefn {GIMPLE function} tree gimple_eh_must_not_throw_fndecl ( @
1676 geh_mnt *eh_mnt_stmt)
1677 Get the function decl to be called by the MUST_NOT_THROW region.
1680 @deftypefn {GIMPLE function} void gimple_eh_must_not_throw_set_fndecl ( @
1681 geh_mnt *eh_mnt_stmt, tree decl)
1682 Set the function decl to be called by GS to DECL.
1686 @node @code{GIMPLE_LABEL}
1687 @subsection @code{GIMPLE_LABEL}
1688 @cindex @code{GIMPLE_LABEL}
1690 @deftypefn {GIMPLE function} glabel *gimple_build_label (tree label)
1691 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
1692 label, @code{LABEL}.
1695 @deftypefn {GIMPLE function} tree gimple_label_label (const glabel *g)
1696 Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
1699 @deftypefn {GIMPLE function} void gimple_label_set_label (glabel *g, tree label)
1700 Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
1704 @node @code{GIMPLE_GOTO}
1705 @subsection @code{GIMPLE_GOTO}
1706 @cindex @code{GIMPLE_GOTO}
1708 @deftypefn {GIMPLE function} ggoto *gimple_build_goto (tree dest)
1709 Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
1712 @deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
1713 Return the destination of the unconditional jump @code{G}.
1716 @deftypefn {GIMPLE function} void gimple_goto_set_dest (ggoto *g, tree dest)
1717 Set @code{DEST} to be the destination of the unconditional jump @code{G}.
1721 @node @code{GIMPLE_NOP}
1722 @subsection @code{GIMPLE_NOP}
1723 @cindex @code{GIMPLE_NOP}
1725 @deftypefn {GIMPLE function} gimple gimple_build_nop (void)
1726 Build a @code{GIMPLE_NOP} statement.
1729 @deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
1730 Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
1733 @node @code{GIMPLE_OMP_ATOMIC_LOAD}
1734 @subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
1735 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
1737 @deftypefn {GIMPLE function} gomp_atomic_load *gimple_build_omp_atomic_load ( @
1739 Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand
1740 side of the assignment. @code{RHS} is the right-hand side of the
1744 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs ( @
1745 gomp_atomic_load *g, tree lhs)
1746 Set the @code{LHS} of an atomic load.
1749 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs ( @
1750 const gomp_atomic_load *g)
1751 Get the @code{LHS} of an atomic load.
1754 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs ( @
1755 gomp_atomic_load *g, tree rhs)
1756 Set the @code{RHS} of an atomic set.
1759 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs ( @
1760 const gomp_atomic_load *g)
1761 Get the @code{RHS} of an atomic set.
1765 @node @code{GIMPLE_OMP_ATOMIC_STORE}
1766 @subsection @code{GIMPLE_OMP_ATOMIC_STORE}
1767 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
1769 @deftypefn {GIMPLE function} gomp_atomic_store *gimple_build_omp_atomic_store ( @
1771 Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
1775 @deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val ( @
1776 gomp_atomic_store *g, tree val)
1777 Set the value being stored in an atomic store.
1780 @deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val ( @
1781 const gomp_atomic_store *g)
1782 Return the value being stored in an atomic store.
1785 @node @code{GIMPLE_OMP_CONTINUE}
1786 @subsection @code{GIMPLE_OMP_CONTINUE}
1787 @cindex @code{GIMPLE_OMP_CONTINUE}
1789 @deftypefn {GIMPLE function} gomp_continue *gimple_build_omp_continue ( @
1790 tree control_def, tree control_use)
1791 Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the
1792 definition of the control variable. @code{CONTROL_USE} is the use of
1793 the control variable.
1796 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def ( @
1797 const gomp_continue *s)
1798 Return the definition of the control variable on a
1799 @code{GIMPLE_OMP_CONTINUE} in @code{S}.
1802 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr ( @
1804 Same as above, but return the pointer.
1807 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def ( @
1809 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
1810 statement in @code{S}.
1813 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use ( @
1814 const gomp_continue *s)
1815 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
1819 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr ( @
1821 Same as above, but return the pointer.
1824 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use ( @
1826 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
1831 @node @code{GIMPLE_OMP_CRITICAL}
1832 @subsection @code{GIMPLE_OMP_CRITICAL}
1833 @cindex @code{GIMPLE_OMP_CRITICAL}
1835 @deftypefn {GIMPLE function} gomp_critical *gimple_build_omp_critical ( @
1836 gimple_seq body, tree name)
1837 Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
1838 statements for which only one thread can execute. @code{NAME} is an
1839 optional identifier for this critical block.
1842 @deftypefn {GIMPLE function} tree gimple_omp_critical_name ( @
1843 const gomp_critical *g)
1844 Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
1847 @deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr ( @
1849 Return a pointer to the name associated with @code{OMP} critical
1853 @deftypefn {GIMPLE function} void gimple_omp_critical_set_name ( @
1854 gomp_critical *g, tree name)
1855 Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
1858 @node @code{GIMPLE_OMP_FOR}
1859 @subsection @code{GIMPLE_OMP_FOR}
1860 @cindex @code{GIMPLE_OMP_FOR}
1862 @deftypefn {GIMPLE function} gomp_for *gimple_build_omp_for (gimple_seq body, @
1863 tree clauses, tree index, tree initial, tree final, tree incr, @
1864 gimple_seq pre_body, enum tree_code omp_for_cond)
1865 Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
1866 inside the for loop. @code{CLAUSES}, are any of the loop
1867 construct's clauses. @code{PRE_BODY} is the
1868 sequence of statements that are loop invariant. @code{INDEX} is the
1869 index variable. @code{INITIAL} is the initial value of @code{INDEX}. @code{FINAL} is
1870 final value of @code{INDEX}. OMP_FOR_COND is the predicate used to
1871 compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression.
1874 @deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
1875 Return the clauses associated with @code{OMP_FOR} @code{G}.
1878 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
1879 Return a pointer to the @code{OMP_FOR} @code{G}.
1882 @deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
1883 Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
1886 @deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
1887 Return the index variable for @code{OMP_FOR} @code{G}.
1890 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
1891 Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
1894 @deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
1895 Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
1898 @deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
1899 Return the initial value for @code{OMP_FOR} @code{G}.
1902 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
1903 Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
1906 @deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
1907 Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
1910 @deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
1911 Return the final value for @code{OMP_FOR} @code{G}.
1914 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
1915 turn a pointer to the final value for @code{OMP_FOR} @code{G}.
1918 @deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
1919 Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
1922 @deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
1923 Return the increment value for @code{OMP_FOR} @code{G}.
1926 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
1927 Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
1930 @deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
1931 Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
1934 @deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
1935 Return the sequence of statements to execute before the @code{OMP_FOR}
1936 statement @code{G} starts.
1939 @deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
1940 Set @code{PRE_BODY} to be the sequence of statements to execute before
1941 the @code{OMP_FOR} statement @code{G} starts.
1944 @deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
1945 Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
1948 @deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
1949 Return the condition code associated with @code{OMP_FOR} @code{G}.
1953 @node @code{GIMPLE_OMP_MASTER}
1954 @subsection @code{GIMPLE_OMP_MASTER}
1955 @cindex @code{GIMPLE_OMP_MASTER}
1957 @deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
1958 Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
1959 statements to be executed by just the master.
1963 @node @code{GIMPLE_OMP_ORDERED}
1964 @subsection @code{GIMPLE_OMP_ORDERED}
1965 @cindex @code{GIMPLE_OMP_ORDERED}
1967 @deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
1968 Build a @code{GIMPLE_OMP_ORDERED} statement.
1970 @code{BODY} is the sequence of statements inside a loop that will
1971 executed in sequence.
1974 @node @code{GIMPLE_OMP_PARALLEL}
1975 @subsection @code{GIMPLE_OMP_PARALLEL}
1976 @cindex @code{GIMPLE_OMP_PARALLEL}
1978 @deftypefn {GIMPLE function} gomp_parallel *gimple_build_omp_parallel (@
1979 gimple_seq body, tree clauses, tree child_fn, tree data_arg)
1980 Build a @code{GIMPLE_OMP_PARALLEL} statement.
1982 @code{BODY} is sequence of statements which are executed in parallel.
1983 @code{CLAUSES}, are the @code{OMP} parallel construct's clauses. @code{CHILD_FN} is
1984 the function created for the parallel threads to execute.
1985 @code{DATA_ARG} are the shared data argument(s).
1988 @deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
1989 Return true if @code{OMP} parallel statement @code{G} has the
1990 @code{GF_OMP_PARALLEL_COMBINED} flag set.
1993 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
1994 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
1998 @deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
1999 Return the body for the @code{OMP} statement @code{G}.
2002 @deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
2003 Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
2006 @deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
2007 Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
2010 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr ( @
2012 Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
2015 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses ( @
2016 gomp_parallel *g, tree clauses)
2017 Set @code{CLAUSES} to be the list of clauses associated with
2018 @code{OMP_PARALLEL} @code{G}.
2021 @deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn ( @
2022 const gomp_parallel *g)
2023 Return the child function used to hold the body of @code{OMP_PARALLEL}
2027 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr ( @
2029 Return a pointer to the child function used to hold the body of
2030 @code{OMP_PARALLEL} @code{G}.
2033 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn ( @
2034 gomp_parallel *g, tree child_fn)
2035 Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
2038 @deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg ( @
2039 const gomp_parallel *g)
2040 Return the artificial argument used to send variables and values
2041 from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
2044 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr ( @
2046 Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
2049 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg ( @
2050 gomp_parallel *g, tree data_arg)
2051 Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
2055 @node @code{GIMPLE_OMP_RETURN}
2056 @subsection @code{GIMPLE_OMP_RETURN}
2057 @cindex @code{GIMPLE_OMP_RETURN}
2059 @deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
2060 Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
2064 @deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
2065 Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
2069 @deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
2070 Return true if @code{OMP} return statement @code{G} has the
2071 @code{GF_OMP_RETURN_NOWAIT} flag set.
2074 @node @code{GIMPLE_OMP_SECTION}
2075 @subsection @code{GIMPLE_OMP_SECTION}
2076 @cindex @code{GIMPLE_OMP_SECTION}
2078 @deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
2079 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
2081 @code{BODY} is the sequence of statements in the section.
2084 @deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
2085 Return true if @code{OMP} section statement @code{G} has the
2086 @code{GF_OMP_SECTION_LAST} flag set.
2089 @deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
2090 Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
2093 @node @code{GIMPLE_OMP_SECTIONS}
2094 @subsection @code{GIMPLE_OMP_SECTIONS}
2095 @cindex @code{GIMPLE_OMP_SECTIONS}
2097 @deftypefn {GIMPLE function} gomp_sections *gimple_build_omp_sections ( @
2098 gimple_seq body, tree clauses)
2099 Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
2100 section statements. @code{CLAUSES} are any of the @code{OMP} sections
2101 construct's clauses: private, firstprivate, lastprivate,
2102 reduction, and nowait.
2106 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
2107 Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
2110 @deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
2111 Return the control variable associated with the
2112 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2115 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
2116 Return a pointer to the clauses associated with the
2117 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2120 @deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
2121 Set @code{CONTROL} to be the set of clauses associated with the
2122 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2125 @deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
2126 Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
2129 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
2130 Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
2133 @deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
2134 Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
2139 @node @code{GIMPLE_OMP_SINGLE}
2140 @subsection @code{GIMPLE_OMP_SINGLE}
2141 @cindex @code{GIMPLE_OMP_SINGLE}
2143 @deftypefn {GIMPLE function} gomp_single *gimple_build_omp_single ( @
2144 gimple_seq body, tree clauses)
2145 Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
2146 statements that will be executed once. @code{CLAUSES} are any of the
2147 @code{OMP} single construct's clauses: private, firstprivate,
2148 copyprivate, nowait.
2151 @deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
2152 Return the clauses associated with @code{OMP_SINGLE} @code{G}.
2155 @deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
2156 Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
2159 @deftypefn {GIMPLE function} void gimple_omp_single_set_clauses ( @
2160 gomp_single *g, tree clauses)
2161 Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
2165 @node @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2166 @subsection @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2167 @cindex @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2169 Like the GENERIC equivalent @code{OMP_STRUCTURED_BLOCK}, this GIMPLE
2170 statement does not correspond directly to an OpenMP directive, and
2171 exists only to permit error checking of transfers of control
2172 in/out of structured block sequences (the @code{diagnose_omp_blocks} pass
2173 in @file{omp-low.cc}). All @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2174 nodes are eliminated during OpenMP lowering.
2176 @deftypefn {GIMPLE function} gimple gimple_build_omp_structured_block (gimple_seq body)
2177 Build a @code{GIMPLE_OMP_STRUCTURED_BLOCK} statement.
2178 @code{BODY} is the sequence of statements in the structured block sequence.
2182 @node @code{GIMPLE_PHI}
2183 @subsection @code{GIMPLE_PHI}
2184 @cindex @code{GIMPLE_PHI}
2186 @deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
2187 Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
2190 @deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
2191 Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
2192 be exactly the number of incoming edges for the basic block
2196 @deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
2197 Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2200 @deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
2201 Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2204 @deftypefn {GIMPLE function} void gimple_phi_set_result (gphi *g, tree result)
2205 Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2208 @deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
2209 Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
2210 @code{GIMPLE_PHI} @code{G}.
2213 @deftypefn {GIMPLE function} void gimple_phi_set_arg (gphi *g, index, @
2214 struct phi_arg_d * phiarg)
2215 Set @code{PHIARG} to be the argument corresponding to incoming edge
2216 @code{INDEX} for @code{GIMPLE_PHI} @code{G}.
2219 @node @code{GIMPLE_RESX}
2220 @subsection @code{GIMPLE_RESX}
2221 @cindex @code{GIMPLE_RESX}
2223 @deftypefn {GIMPLE function} gresx *gimple_build_resx (int region)
2224 Build a @code{GIMPLE_RESX} statement which is a statement. This
2225 statement is a placeholder for _Unwind_Resume before we know if a
2226 function call or a branch is needed. @code{REGION} is the exception
2227 region from which control is flowing.
2230 @deftypefn {GIMPLE function} int gimple_resx_region (const gresx *g)
2231 Return the region number for @code{GIMPLE_RESX} @code{G}.
2234 @deftypefn {GIMPLE function} void gimple_resx_set_region (gresx *g, int region)
2235 Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
2238 @node @code{GIMPLE_RETURN}
2239 @subsection @code{GIMPLE_RETURN}
2240 @cindex @code{GIMPLE_RETURN}
2242 @deftypefn {GIMPLE function} greturn *gimple_build_return (tree retval)
2243 Build a @code{GIMPLE_RETURN} statement whose return value is retval.
2246 @deftypefn {GIMPLE function} tree gimple_return_retval (const greturn *g)
2247 Return the return value for @code{GIMPLE_RETURN} @code{G}.
2250 @deftypefn {GIMPLE function} void gimple_return_set_retval (greturn *g, @
2252 Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
2255 @node @code{GIMPLE_SWITCH}
2256 @subsection @code{GIMPLE_SWITCH}
2257 @cindex @code{GIMPLE_SWITCH}
2259 @deftypefn {GIMPLE function} gswitch *gimple_build_switch (tree index, @
2260 tree default_label, @code{vec}<tree> *args)
2261 Build a @code{GIMPLE_SWITCH} statement. @code{INDEX} is the index variable
2262 to switch on, and @code{DEFAULT_LABEL} represents the default label.
2263 @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
2264 non-default case labels. Each label is a tree of code @code{CASE_LABEL_EXPR}.
2267 @deftypefn {GIMPLE function} unsigned gimple_switch_num_labels ( @
2269 Return the number of labels associated with the switch statement
2273 @deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gswitch *g, @
2275 Set @code{NLABELS} to be the number of labels for the switch statement
2279 @deftypefn {GIMPLE function} tree gimple_switch_index (const gswitch *g)
2280 Return the index variable used by the switch statement @code{G}.
2283 @deftypefn {GIMPLE function} void gimple_switch_set_index (gswitch *g, @
2285 Set @code{INDEX} to be the index variable for switch statement @code{G}.
2288 @deftypefn {GIMPLE function} tree gimple_switch_label (const gswitch *g, @
2290 Return the label numbered @code{INDEX}. The default label is 0, followed
2291 by any labels in a switch statement.
2294 @deftypefn {GIMPLE function} void gimple_switch_set_label (gswitch *g, @
2295 unsigned index, tree label)
2296 Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
2300 @deftypefn {GIMPLE function} tree gimple_switch_default_label ( @
2302 Return the default label for a switch statement.
2305 @deftypefn {GIMPLE function} void gimple_switch_set_default_label (gswitch *g, @
2307 Set the default label for a switch statement.
2311 @node @code{GIMPLE_TRY}
2312 @subsection @code{GIMPLE_TRY}
2313 @cindex @code{GIMPLE_TRY}
2315 @deftypefn {GIMPLE function} gtry *gimple_build_try (gimple_seq eval, @
2316 gimple_seq cleanup, unsigned int kind)
2317 Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the
2318 expression to evaluate. @code{CLEANUP} is a sequence of statements to
2319 run at clean-up time. @code{KIND} is the enumeration value
2320 @code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
2321 or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
2325 @deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
2326 Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
2327 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
2330 @deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
2331 Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2334 @deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
2335 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
2339 @deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
2340 Return the sequence of statements used as the cleanup body for
2341 @code{GIMPLE_TRY} @code{G}.
2344 @deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
2345 bool catch_is_cleanup)
2346 Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2349 @deftypefn {GIMPLE function} void gimple_try_set_eval (gtry *g, gimple_seq eval)
2350 Set @code{EVAL} to be the sequence of statements to use as the body for
2351 @code{GIMPLE_TRY} @code{G}.
2354 @deftypefn {GIMPLE function} void gimple_try_set_cleanup (gtry *g, @
2356 Set @code{CLEANUP} to be the sequence of statements to use as the
2357 cleanup body for @code{GIMPLE_TRY} @code{G}.
2360 @node @code{GIMPLE_WITH_CLEANUP_EXPR}
2361 @subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
2362 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
2364 @deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
2365 Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement. @code{CLEANUP} is the
2366 clean-up expression.
2369 @deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
2370 Return the cleanup sequence for cleanup statement @code{G}.
2373 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
2374 Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
2377 @deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
2378 Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2381 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
2382 Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2386 @node GIMPLE sequences
2387 @section GIMPLE sequences
2388 @cindex GIMPLE sequences
2390 GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
2391 used in @code{GENERIC}. They are used to chain statements together, and
2392 when used in conjunction with sequence iterators, provide a
2393 framework for iterating through statements.
2395 GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
2396 commonly passed by reference to functions dealing with sequences.
2397 The type for a sequence pointer is @code{gimple_seq} which is the same
2398 as struct @code{gimple_sequence} *. When declaring a local sequence,
2399 you can define a local variable of type struct @code{gimple_sequence}.
2400 When declaring a sequence allocated on the garbage collected
2401 heap, use the function @code{gimple_seq_alloc} documented below.
2403 There are convenience functions for iterating through sequences
2404 in the section entitled Sequence Iterators.
2406 Below is a list of functions to manipulate and query sequences.
2408 @deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
2409 Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
2410 not @code{NULL}. If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
2413 @deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
2414 Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
2415 @code{NULL}. If *@code{DEST} is @code{NULL}, allocate a new sequence before
2419 @deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
2420 Perform a deep copy of sequence @code{SRC} and return the result.
2423 @deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
2424 Reverse the order of the statements in the sequence @code{SEQ}. Return
2428 @deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
2429 Return the first statement in sequence @code{S}.
2432 @deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
2433 Return the last statement in sequence @code{S}.
2436 @deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
2437 Set the last statement in sequence @code{S} to the statement in @code{LAST}.
2440 @deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
2441 Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
2444 @deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
2445 Initialize sequence @code{S} to an empty sequence.
2448 @deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
2449 Allocate a new sequence in the garbage collected store and return
2453 @deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
2454 Copy the sequence @code{SRC} into the sequence @code{DEST}.
2457 @deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
2458 Return true if the sequence @code{S} is empty.
2461 @deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
2462 Returns the sequence of statements in @code{BB}.
2465 @deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
2466 Sets the sequence of statements in @code{BB} to @code{SEQ}.
2469 @deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
2470 Determine whether @code{SEQ} contains exactly one statement.
2473 @node Sequence iterators
2474 @section Sequence iterators
2475 @cindex Sequence iterators
2477 Sequence iterators are convenience constructs for iterating
2478 through statements in a sequence. Given a sequence @code{SEQ}, here is
2479 a typical use of gimple sequence iterators:
2482 gimple_stmt_iterator gsi;
2484 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
2486 gimple g = gsi_stmt (gsi);
2487 /* Do something with gimple statement @code{G}. */
2491 Backward iterations are possible:
2494 for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
2497 Forward and backward iterations on basic blocks are possible with
2498 @code{gsi_start_bb} and @code{gsi_last_bb}.
2500 In the documentation below we sometimes refer to enum
2501 @code{gsi_iterator_update}. The valid options for this enumeration are:
2504 @item @code{GSI_NEW_STMT}
2505 Only valid when a single statement is added. Move the iterator to it.
2507 @item @code{GSI_SAME_STMT}
2508 Leave the iterator at the same statement.
2510 @item @code{GSI_CONTINUE_LINKING}
2511 Move iterator to whatever position is suitable for linking other
2512 statements in the same direction.
2515 Below is a list of the functions used to manipulate and use
2516 statement iterators.
2518 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
2519 Return a new iterator pointing to the sequence @code{SEQ}'s first
2520 statement. If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
2521 Use @code{gsi_start_bb} instead when the iterator needs to always have
2522 the correct basic block set.
2525 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
2526 Return a new iterator pointing to the first statement in basic
2530 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
2531 Return a new iterator initially pointing to the last statement of
2532 sequence @code{SEQ}. If @code{SEQ} is empty, the iterator's basic block is
2533 @code{NULL}. Use @code{gsi_last_bb} instead when the iterator needs to always
2534 have the correct basic block set.
2537 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
2538 Return a new iterator pointing to the last statement in basic
2542 @deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
2543 Return @code{TRUE} if at the end of @code{I}.
2546 @deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
2547 Return @code{TRUE} if we're one statement before the end of @code{I}.
2550 @deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
2551 Advance the iterator to the next gimple statement.
2554 @deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
2555 Advance the iterator to the previous gimple statement.
2558 @deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
2559 Return the current stmt.
2562 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb)
2563 Return a block statement iterator that points to the first
2564 non-label statement in block @code{BB}.
2567 @deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i)
2568 Return a pointer to the current stmt.
2571 @deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
2572 Return the basic block associated with this iterator.
2575 @deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
2576 Return the sequence associated with this iterator.
2579 @deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
2580 Remove the current stmt from the sequence. The iterator is
2581 updated to point to the next statement. When @code{REMOVE_EH_INFO} is
2582 true we remove the statement pointed to by iterator @code{I} from the @code{EH}
2583 tables. Otherwise we do not modify the @code{EH} tables. Generally,
2584 @code{REMOVE_EH_INFO} should be true when the statement is going to be
2585 removed from the @code{IL} and not reinserted elsewhere.
2588 @deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2589 Links the sequence of statements @code{SEQ} before the statement pointed
2590 by iterator @code{I}. @code{MODE} indicates what to do with the iterator
2591 after insertion (see @code{enum gsi_iterator_update} above).
2594 @deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
2595 Links statement @code{G} before the statement pointed-to by iterator @code{I}.
2596 Updates iterator @code{I} according to @code{MODE}.
2599 @deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, @
2600 gimple_seq seq, enum gsi_iterator_update mode)
2601 Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
2602 @code{MODE} is as in @code{gsi_insert_after}.
2605 @deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
2606 gimple g, enum gsi_iterator_update mode)
2607 Links statement @code{G} after the statement pointed-to by iterator @code{I}.
2608 @code{MODE} is as in @code{gsi_insert_after}.
2611 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
2612 Move all statements in the sequence after @code{I} to a new sequence.
2613 Return this new sequence.
2616 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
2617 Move all statements in the sequence before @code{I} to a new sequence.
2618 Return this new sequence.
2621 @deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @
2622 gimple stmt, bool update_eh_info)
2623 Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO}
2624 is true, the exception handling information of the original
2625 statement is moved to the new statement.
2628 @deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
2629 gimple stmt, enum gsi_iterator_update mode)
2630 Insert statement @code{STMT} before the statement pointed-to by iterator
2631 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2632 specifies how to update iterator @code{I} after insertion (see enum
2633 @code{gsi_iterator_update}).
2636 @deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, @
2637 gimple_seq seq, enum gsi_iterator_update mode)
2638 Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
2641 @deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
2642 gimple stmt, enum gsi_iterator_update mode)
2643 Insert statement @code{STMT} after the statement pointed-to by iterator
2644 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2645 specifies how to update iterator @code{I} after insertion (see enum
2646 @code{gsi_iterator_update}).
2649 @deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, @
2650 gimple_seq seq, enum gsi_iterator_update mode)
2651 Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
2654 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
2655 Finds iterator for @code{STMT}.
2658 @deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, @
2659 gimple_stmt_iterator *to)
2660 Move the statement at @code{FROM} so it comes right after the statement
2664 @deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, @
2665 gimple_stmt_iterator *to)
2666 Move the statement at @code{FROM} so it comes right before the statement
2670 @deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, @
2672 Move the statement at @code{FROM} to the end of basic block @code{BB}.
2675 @deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
2676 Add @code{STMT} to the pending list of edge @code{E}. No actual insertion is
2677 made until a call to @code{gsi_commit_edge_inserts}() is made.
2680 @deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
2681 Add the sequence of statements in @code{SEQ} to the pending list of edge
2682 @code{E}. No actual insertion is made until a call to
2683 @code{gsi_commit_edge_inserts}() is made.
2686 @deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
2687 Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}. If a new
2688 block has to be created, it is returned.
2691 @deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
2692 Commit insertions pending at edge @code{E}. If a new block is created,
2693 set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
2696 @deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
2697 This routine will commit all pending edge insertions, creating
2698 any new basic blocks which are necessary.
2702 @node Adding a new GIMPLE statement code
2703 @section Adding a new GIMPLE statement code
2704 @cindex Adding a new GIMPLE statement code
2706 The first step in adding a new GIMPLE statement code, is
2707 modifying the file @code{gimple.def}, which contains all the GIMPLE
2708 codes. Then you must add a corresponding gimple subclass
2709 located in @code{gimple.h}. This in turn, will require you to add a
2710 corresponding @code{GTY} tag in @code{gsstruct.def}, and code to handle
2711 this tag in @code{gss_for_code} which is located in @code{gimple.cc}.
2713 In order for the garbage collector to know the size of the
2714 structure you created in @code{gimple.h}, you need to add a case to
2715 handle your new GIMPLE statement in @code{gimple_size} which is located
2716 in @code{gimple.cc}.
2718 You will probably want to create a function to build the new
2719 gimple statement in @code{gimple.cc}. The function should be called
2720 @code{gimple_build_@var{new-tuple-name}}, and should return the new tuple
2721 as a pointer to the appropriate gimple subclass.
2723 If your new statement requires accessors for any members or
2724 operands it may have, put simple inline accessors in
2725 @code{gimple.h} and any non-trivial accessors in @code{gimple.cc} with a
2726 corresponding prototype in @code{gimple.h}.
2728 You should add the new statement subclass to the class hierarchy diagram
2729 in @code{gimple.texi}.
2732 @node Statement and operand traversals
2733 @section Statement and operand traversals
2734 @cindex Statement and operand traversals
2736 There are two functions available for walking statements and
2737 sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
2738 accordingly, and a third function for walking the operands in a
2739 statement: @code{walk_gimple_op}.
2741 @deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, @
2742 walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2743 This function is used to walk the current statement in @code{GSI},
2744 optionally using traversal state stored in @code{WI}. If @code{WI} is @code{NULL}, no
2745 state is kept during the traversal.
2747 The callback @code{CALLBACK_STMT} is called. If @code{CALLBACK_STMT} returns
2748 true, it means that the callback function has handled all the
2749 operands of the statement and it is not necessary to walk its
2752 If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
2753 called on each operand of the statement via @code{walk_gimple_op}. If
2754 @code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
2755 operands are not scanned.
2757 The return value is that returned by the last call to
2758 @code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
2762 @deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @
2763 walk_tree_fn callback_op, struct walk_stmt_info *wi)
2764 Use this function to walk the operands of statement @code{STMT}. Every
2765 operand is walked via @code{walk_tree} with optional state information
2768 @code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
2769 Additional parameters to @code{walk_tree} must be stored in @code{WI}. For
2770 each operand @code{OP}, @code{walk_tree} is called as:
2773 walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{PSET})
2776 If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
2777 operands are not scanned. The return value is that returned by
2778 the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
2783 @deftypefn {GIMPLE function} tree walk_gimple_seq (gimple_seq seq, @
2784 walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2785 This function walks all the statements in the sequence @code{SEQ}
2786 calling @code{walk_gimple_stmt} on each one. @code{WI} is as in
2787 @code{walk_gimple_stmt}. If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
2788 is stopped and the value returned. Otherwise, all the statements
2789 are walked and @code{NULL_TREE} returned.