Add -lm to link_sanitizer_common
[official-gcc.git] / gcc / doc / gimple.texi
blob7bd9fd51b78f4a9068d60d73fde2c1e74229caa3
1 @c Copyright (C) 2008-2013 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.
6 @node GIMPLE
7 @chapter GIMPLE
8 @cindex GIMPLE
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}.
71 @menu
72 * Tuple representation::
73 * GIMPLE instruction set::
74 * GIMPLE Exception Handling::
75 * Temporaries::
76 * Operands::
77 * Manipulating GIMPLE statements::
78 * Tuple specific accessors::
79 * GIMPLE sequences::
80 * Sequence iterators::
81 * Adding a new GIMPLE statement code::
82 * Statement and operand traversals::
83 @end menu
85 @node Tuple representation
86 @section Tuple representation
87 @cindex tuples
89 GIMPLE instructions are tuples of variable size divided in two
90 groups: a header describing the instruction and its locations,
91 and a variable length body with all the operands. Tuples are
92 organized into a hierarchy with 3 main classes of tuples.
94 @subsection @code{gimple_statement_base} (gsbase)
95 @cindex gimple_statement_base
97 This is the root of the hierarchy, it holds basic information
98 needed by most GIMPLE statements. There are some fields that
99 may not be relevant to every GIMPLE statement, but those were
100 moved into the base structure to take advantage of holes left by
101 other fields (thus making the structure more compact).  The
102 structure takes 4 words (32 bytes) on 64 bit hosts:
104 @multitable {@code{references_memory_p}} {Size (bits)}
105 @item Field                             @tab Size (bits)
106 @item @code{code}                       @tab 8
107 @item @code{subcode}                    @tab 16
108 @item @code{no_warning}                 @tab 1
109 @item @code{visited}                    @tab 1
110 @item @code{nontemporal_move}           @tab 1
111 @item @code{plf}                        @tab 2
112 @item @code{modified}                   @tab 1
113 @item @code{has_volatile_ops}           @tab 1
114 @item @code{references_memory_p}        @tab 1
115 @item @code{uid}                        @tab 32
116 @item @code{location}                   @tab 32
117 @item @code{num_ops}                    @tab 32
118 @item @code{bb}                         @tab 64
119 @item @code{block}                      @tab 63
120 @item Total size                        @tab 32 bytes   
121 @end multitable
123 @itemize @bullet
124 @item @code{code}
125 Main identifier for a GIMPLE instruction.
127 @item @code{subcode}
128 Used to distinguish different variants of the same basic
129 instruction or provide flags applicable to a given code. The
130 @code{subcode} flags field has different uses depending on the code of
131 the instruction, but mostly it distinguishes instructions of the
132 same family. The most prominent use of this field is in
133 assignments, where subcode indicates the operation done on the
134 RHS of the assignment. For example, a = b + c is encoded as
135 @code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
137 @item @code{no_warning}
138 Bitflag to indicate whether a warning has already been issued on
139 this statement.
141 @item @code{visited}
142 General purpose ``visited'' marker. Set and cleared by each pass
143 when needed.
145 @item @code{nontemporal_move}
146 Bitflag used in assignments that represent non-temporal moves.
147 Although this bitflag is only used in assignments, it was moved
148 into the base to take advantage of the bit holes left by the
149 previous fields.
151 @item @code{plf}
152 Pass Local Flags. This 2-bit mask can be used as general purpose
153 markers by any pass. Passes are responsible for clearing and
154 setting these two flags accordingly.
156 @item @code{modified}
157 Bitflag to indicate whether the statement has been modified.
158 Used mainly by the operand scanner to determine when to re-scan a
159 statement for operands.
161 @item @code{has_volatile_ops}
162 Bitflag to indicate whether this statement contains operands that
163 have been marked volatile.
165 @item @code{references_memory_p}
166 Bitflag to indicate whether this statement contains memory
167 references (i.e., its operands are either global variables, or
168 pointer dereferences or anything that must reside in memory).
170 @item @code{uid}
171 This is an unsigned integer used by passes that want to assign
172 IDs to every statement. These IDs must be assigned and used by
173 each pass.
175 @item @code{location}
176 This is a @code{location_t} identifier to specify source code
177 location for this statement. It is inherited from the front
178 end.
180 @item @code{num_ops}
181 Number of operands that this statement has. This specifies the
182 size of the operand vector embedded in the tuple. Only used in
183 some tuples, but it is declared in the base tuple to take
184 advantage of the 32-bit hole left by the previous fields.
186 @item @code{bb}
187 Basic block holding the instruction.
189 @item @code{block}
190 Lexical block holding this statement.  Also used for debug
191 information generation.
192 @end itemize
194 @subsection @code{gimple_statement_with_ops}
195 @cindex gimple_statement_with_ops
197 This tuple is actually split in two:
198 @code{gimple_statement_with_ops_base} and
199 @code{gimple_statement_with_ops}. This is needed to accommodate the
200 way the operand vector is allocated. The operand vector is
201 defined to be an array of 1 element. So, to allocate a dynamic
202 number of operands, the memory allocator (@code{gimple_alloc}) simply
203 allocates enough memory to hold the structure itself plus @code{N
204 - 1} operands which run ``off the end'' of the structure. For
205 example, to allocate space for a tuple with 3 operands,
206 @code{gimple_alloc} reserves @code{sizeof (struct
207 gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
209 On the other hand, several fields in this tuple need to be shared
210 with the @code{gimple_statement_with_memory_ops} tuple. So, these
211 common fields are placed in @code{gimple_statement_with_ops_base} which
212 is then inherited from the other two tuples.
215 @multitable {@code{def_ops}}    {48 + 8 * @code{num_ops} bytes}
216 @item   @code{gsbase}           @tab 256        
217 @item   @code{def_ops}          @tab 64 
218 @item   @code{use_ops}          @tab 64 
219 @item   @code{op}               @tab @code{num_ops} * 64        
220 @item   Total size              @tab 48 + 8 * @code{num_ops} bytes
221 @end multitable
223 @itemize @bullet
224 @item @code{gsbase}
225 Inherited from @code{struct gimple_statement_base}.
227 @item @code{def_ops}
228 Array of pointers into the operand array indicating all the slots that
229 contain a variable written-to by the statement. This array is
230 also used for immediate use chaining. Note that it would be
231 possible to not rely on this array, but the changes required to
232 implement this are pretty invasive.
234 @item @code{use_ops}
235 Similar to @code{def_ops} but for variables read by the statement.
237 @item @code{op}
238 Array of trees with @code{num_ops} slots.
239 @end itemize
241 @subsection @code{gimple_statement_with_memory_ops}
243 This tuple is essentially identical to @code{gimple_statement_with_ops},
244 except that it contains 4 additional fields to hold vectors
245 related memory stores and loads.  Similar to the previous case,
246 the structure is split in two to accommodate for the operand
247 vector (@code{gimple_statement_with_memory_ops_base} and
248 @code{gimple_statement_with_memory_ops}).
251 @multitable {@code{vdef_ops}}   {80 + 8 * @code{num_ops} bytes}
252 @item Field                     @tab Size (bits)
253 @item @code{gsbase}             @tab 256
254 @item @code{def_ops}            @tab 64
255 @item @code{use_ops}            @tab 64
256 @item @code{vdef_ops}           @tab 64
257 @item @code{vuse_ops}           @tab 64
258 @item @code{stores}             @tab 64 
259 @item @code{loads}              @tab 64 
260 @item @code{op}                 @tab @code{num_ops} * 64        
261 @item Total size                @tab 80 + 8 * @code{num_ops} bytes
262 @end multitable
264 @itemize @bullet
265 @item @code{vdef_ops}
266 Similar to @code{def_ops} but for @code{VDEF} operators. There is
267 one entry per memory symbol written by this statement. This is
268 used to maintain the memory SSA use-def and def-def chains.
270 @item @code{vuse_ops}
271 Similar to @code{use_ops} but for @code{VUSE} operators. There is
272 one entry per memory symbol loaded by this statement. This is
273 used to maintain the memory SSA use-def chains.
275 @item @code{stores}
276 Bitset with all the UIDs for the symbols written-to by the
277 statement.  This is different than @code{vdef_ops} in that all the
278 affected symbols are mentioned in this set.  If memory
279 partitioning is enabled, the @code{vdef_ops} vector will refer to memory
280 partitions. Furthermore, no SSA information is stored in this
281 set.
283 @item @code{loads}
284 Similar to @code{stores}, but for memory loads. (Note that there
285 is some amount of redundancy here, it should be possible to
286 reduce memory utilization further by removing these sets).
287 @end itemize
289 All the other tuples are defined in terms of these three basic
290 ones. Each tuple will add some fields. The main gimple type
291 is defined to be the union of all these structures (@code{GTY} markers
292 elided for clarity):
294 @smallexample
295 union gimple_statement_d
297   struct gimple_statement_base gsbase;
298   struct gimple_statement_with_ops gsops;
299   struct gimple_statement_with_memory_ops gsmem;
300   struct gimple_statement_omp omp;
301   struct gimple_statement_bind gimple_bind;
302   struct gimple_statement_catch gimple_catch;
303   struct gimple_statement_eh_filter gimple_eh_filter;
304   struct gimple_statement_phi gimple_phi;
305   struct gimple_statement_resx gimple_resx;
306   struct gimple_statement_try gimple_try;
307   struct gimple_statement_wce gimple_wce;
308   struct gimple_statement_asm gimple_asm;
309   struct gimple_statement_omp_critical gimple_omp_critical;
310   struct gimple_statement_omp_for gimple_omp_for;
311   struct gimple_statement_omp_parallel gimple_omp_parallel;
312   struct gimple_statement_omp_task gimple_omp_task;
313   struct gimple_statement_omp_sections gimple_omp_sections;
314   struct gimple_statement_omp_single gimple_omp_single;
315   struct gimple_statement_omp_continue gimple_omp_continue;
316   struct gimple_statement_omp_atomic_load gimple_omp_atomic_load;
317   struct gimple_statement_omp_atomic_store gimple_omp_atomic_store;
319 @end smallexample
322 @node GIMPLE instruction set
323 @section GIMPLE instruction set
324 @cindex GIMPLE instruction set
326 The following table briefly describes the GIMPLE instruction set.
328 @multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE}
329 @item Instruction                       @tab High GIMPLE        @tab Low GIMPLE
330 @item @code{GIMPLE_ASM}                 @tab x                  @tab x
331 @item @code{GIMPLE_ASSIGN}              @tab x                  @tab x
332 @item @code{GIMPLE_BIND}                @tab x                  @tab
333 @item @code{GIMPLE_CALL}                @tab x                  @tab x
334 @item @code{GIMPLE_CATCH}               @tab x                  @tab
335 @item @code{GIMPLE_COND}                @tab x                  @tab x
336 @item @code{GIMPLE_DEBUG}               @tab x                  @tab x
337 @item @code{GIMPLE_EH_FILTER}           @tab x                  @tab
338 @item @code{GIMPLE_GOTO}                @tab x                  @tab x
339 @item @code{GIMPLE_LABEL}               @tab x                  @tab x
340 @item @code{GIMPLE_NOP}                 @tab x                  @tab x
341 @item @code{GIMPLE_OMP_ATOMIC_LOAD}     @tab x                  @tab x
342 @item @code{GIMPLE_OMP_ATOMIC_STORE}    @tab x                  @tab x
343 @item @code{GIMPLE_OMP_CONTINUE}        @tab x                  @tab x
344 @item @code{GIMPLE_OMP_CRITICAL}        @tab x                  @tab x
345 @item @code{GIMPLE_OMP_FOR}             @tab x                  @tab x
346 @item @code{GIMPLE_OMP_MASTER}          @tab x                  @tab x
347 @item @code{GIMPLE_OMP_ORDERED}         @tab x                  @tab x
348 @item @code{GIMPLE_OMP_PARALLEL}        @tab x                  @tab x
349 @item @code{GIMPLE_OMP_RETURN}          @tab x                  @tab x
350 @item @code{GIMPLE_OMP_SECTION}         @tab x                  @tab x
351 @item @code{GIMPLE_OMP_SECTIONS}        @tab x                  @tab x
352 @item @code{GIMPLE_OMP_SECTIONS_SWITCH} @tab x                  @tab x
353 @item @code{GIMPLE_OMP_SINGLE}          @tab x                  @tab x
354 @item @code{GIMPLE_PHI}                 @tab                    @tab x
355 @item @code{GIMPLE_RESX}                @tab                    @tab x
356 @item @code{GIMPLE_RETURN}              @tab x                  @tab x
357 @item @code{GIMPLE_SWITCH}              @tab x                  @tab x
358 @item @code{GIMPLE_TRY}                 @tab x                  @tab
359 @end multitable
361 @node GIMPLE Exception Handling
362 @section Exception Handling
363 @cindex GIMPLE Exception Handling
365 Other exception handling constructs are represented using
366 @code{GIMPLE_TRY_CATCH}.  @code{GIMPLE_TRY_CATCH} has two operands.  The
367 first operand is a sequence of statements to execute.  If executing
368 these statements does not throw an exception, then the second operand
369 is ignored.  Otherwise, if an exception is thrown, then the second
370 operand of the @code{GIMPLE_TRY_CATCH} is checked.  The second
371 operand may have the following forms:
373 @enumerate
375 @item A sequence of statements to execute.  When an exception occurs,
376 these statements are executed, and then the exception is rethrown.
378 @item A sequence of @code{GIMPLE_CATCH} statements.  Each
379 @code{GIMPLE_CATCH} has a list of applicable exception types and
380 handler code.  If the thrown exception matches one of the caught
381 types, the associated handler code is executed.  If the handler
382 code falls off the bottom, execution continues after the original
383 @code{GIMPLE_TRY_CATCH}.
385 @item A @code{GIMPLE_EH_FILTER} statement.  This has a list of
386 permitted exception types, and code to handle a match failure.  If the
387 thrown exception does not match one of the allowed types, the
388 associated match failure code is executed.  If the thrown exception
389 does match, it continues unwinding the stack looking for the next
390 handler.
392 @end enumerate
394 Currently throwing an exception is not directly represented in
395 GIMPLE, since it is implemented by calling a function.  At some
396 point in the future we will want to add some way to express that
397 the call will throw an exception of a known type.
399 Just before running the optimizers, the compiler lowers the
400 high-level EH constructs above into a set of @samp{goto}s, magic
401 labels, and EH regions.  Continuing to unwind at the end of a
402 cleanup is represented with a @code{GIMPLE_RESX}.
405 @node Temporaries
406 @section Temporaries
407 @cindex Temporaries
409 When gimplification encounters a subexpression that is too
410 complex, it creates a new temporary variable to hold the value of
411 the subexpression, and adds a new statement to initialize it
412 before the current statement. These special temporaries are known
413 as @samp{expression temporaries}, and are allocated using
414 @code{get_formal_tmp_var}.  The compiler tries to always evaluate
415 identical expressions into the same temporary, to simplify
416 elimination of redundant calculations.
418 We can only use expression temporaries when we know that it will
419 not be reevaluated before its value is used, and that it will not
420 be otherwise modified@footnote{These restrictions are derived
421 from those in Morgan 4.8.}. Other temporaries can be allocated
422 using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
424 Currently, an expression like @code{a = b + 5} is not reduced any
425 further.  We tried converting it to something like
426 @smallexample
427 T1 = b + 5;
428 a = T1;
429 @end smallexample
430 but this bloated the representation for minimal benefit.  However, a
431 variable which must live in memory cannot appear in an expression; its
432 value is explicitly loaded into a temporary first.  Similarly, storing
433 the value of an expression to a memory variable goes through a
434 temporary.
436 @node Operands
437 @section Operands
438 @cindex Operands
440 In general, expressions in GIMPLE consist of an operation and the
441 appropriate number of simple operands; these operands must either be a
442 GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
443 variable.  More complex operands are factored out into temporaries, so
444 that
445 @smallexample
446 a = b + c + d
447 @end smallexample
448 becomes
449 @smallexample
450 T1 = b + c;
451 a = T1 + d;
452 @end smallexample
454 The same rule holds for arguments to a @code{GIMPLE_CALL}.
456 The target of an assignment is usually a variable, but can also be a
457 @code{MEM_REF} or a compound lvalue as described below.
459 @menu
460 * Compound Expressions::
461 * Compound Lvalues::
462 * Conditional Expressions::
463 * Logical Operators::
464 @end menu
466 @node Compound Expressions
467 @subsection Compound Expressions
468 @cindex Compound Expressions
470 The left-hand side of a C comma expression is simply moved into a separate
471 statement.
473 @node Compound Lvalues
474 @subsection Compound Lvalues
475 @cindex Compound Lvalues
477 Currently compound lvalues involving array and structure field references
478 are not broken down; an expression like @code{a.b[2] = 42} is not reduced
479 any further (though complex array subscripts are).  This restriction is a
480 workaround for limitations in later optimizers; if we were to convert this
483 @smallexample
484 T1 = &a.b;
485 T1[2] = 42;
486 @end smallexample
488 alias analysis would not remember that the reference to @code{T1[2]} came
489 by way of @code{a.b}, so it would think that the assignment could alias
490 another member of @code{a}; this broke @code{struct-alias-1.c}.  Future
491 optimizer improvements may make this limitation unnecessary.
493 @node Conditional Expressions
494 @subsection Conditional Expressions
495 @cindex Conditional Expressions
497 A C @code{?:} expression is converted into an @code{if} statement with
498 each branch assigning to the same temporary.  So,
500 @smallexample
501 a = b ? c : d;
502 @end smallexample
503 becomes
504 @smallexample
505 if (b == 1)
506   T1 = c;
507 else
508   T1 = d;
509 a = T1;
510 @end smallexample
512 The GIMPLE level if-conversion pass re-introduces @code{?:}
513 expression, if appropriate. It is used to vectorize loops with
514 conditions using vector conditional operations.
516 Note that in GIMPLE, @code{if} statements are represented using
517 @code{GIMPLE_COND}, as described below.
519 @node Logical Operators
520 @subsection Logical Operators
521 @cindex Logical Operators
523 Except when they appear in the condition operand of a
524 @code{GIMPLE_COND}, logical `and' and `or' operators are simplified
525 as follows: @code{a = b && c} becomes
527 @smallexample
528 T1 = (bool)b;
529 if (T1 == true)
530   T1 = (bool)c;
531 a = T1;
532 @end smallexample
534 Note that @code{T1} in this example cannot be an expression temporary,
535 because it has two different assignments.
537 @subsection Manipulating operands
539 All gimple operands are of type @code{tree}.  But only certain
540 types of trees are allowed to be used as operand tuples.  Basic
541 validation is controlled by the function
542 @code{get_gimple_rhs_class}, which given a tree code, returns an
543 @code{enum} with the following values of type @code{enum
544 gimple_rhs_class}
546 @itemize @bullet
547 @item @code{GIMPLE_INVALID_RHS}
548 The tree cannot be used as a GIMPLE operand.
550 @item @code{GIMPLE_TERNARY_RHS}
551 The tree is a valid GIMPLE ternary operation.
553 @item @code{GIMPLE_BINARY_RHS}
554 The tree is a valid GIMPLE binary operation.
556 @item @code{GIMPLE_UNARY_RHS}
557 The tree is a valid GIMPLE unary operation.
559 @item @code{GIMPLE_SINGLE_RHS}
560 The tree is a single object, that cannot be split into simpler
561 operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc).
563 This operand class also acts as an escape hatch for tree nodes
564 that may be flattened out into the operand vector, but would need
565 more than two slots on the RHS.  For instance, a @code{COND_EXPR}
566 expression of the form @code{(a op b) ? x : y} could be flattened
567 out on the operand vector using 4 slots, but it would also
568 require additional processing to distinguish @code{c = a op b}
569 from @code{c = a op b ? x : y}.  Something similar occurs with
570 @code{ASSERT_EXPR}.   In time, these special case tree
571 expressions should be flattened into the operand vector.
572 @end itemize
574 For tree nodes in the categories @code{GIMPLE_TERNARY_RHS},
575 @code{GIMPLE_BINARY_RHS} and @code{GIMPLE_UNARY_RHS}, they cannot be
576 stored inside tuples directly.  They first need to be flattened and
577 separated into individual components.  For instance, given the GENERIC
578 expression
580 @smallexample
581 a = b + c
582 @end smallexample
584 its tree representation is:
586 @smallexample
587 MODIFY_EXPR <VAR_DECL  <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>
588 @end smallexample
590 In this case, the GIMPLE form for this statement is logically
591 identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
592 on the RHS of the assignment is not represented as a tree,
593 instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree
594 and flattened into the GIMPLE tuple as follows:
596 @smallexample
597 GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>
598 @end smallexample
600 @subsection Operand vector allocation
602 The operand vector is stored at the bottom of the three tuple
603 structures that accept operands. This means, that depending on
604 the code of a given statement, its operand vector will be at
605 different offsets from the base of the structure.  To access
606 tuple operands use the following accessors
608 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
609 Returns the number of operands in statement G.
610 @end deftypefn
612 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
613 Returns operand @code{I} from statement @code{G}.
614 @end deftypefn
616 @deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
617 Returns a pointer into the operand vector for statement @code{G}.  This
618 is computed using an internal table called @code{gimple_ops_offset_}[].
619 This table is indexed by the gimple code of @code{G}.
621 When the compiler is built, this table is filled-in using the
622 sizes of the structures used by each statement code defined in
623 gimple.def.  Since the operand vector is at the bottom of the
624 structure, for a gimple code @code{C} the offset is computed as sizeof
625 (struct-of @code{C}) - sizeof (tree).
627 This mechanism adds one memory indirection to every access when
628 using @code{gimple_op}(), if this becomes a bottleneck, a pass can
629 choose to memoize the result from @code{gimple_ops}() and use that to
630 access the operands.
631 @end deftypefn
633 @subsection Operand validation
635 When adding a new operand to a gimple statement, the operand will
636 be validated according to what each tuple accepts in its operand
637 vector.  These predicates are called by the
638 @code{gimple_@var{name}_set_...()}.  Each tuple will use one of the
639 following predicates (Note, this list is not exhaustive):
641 @deftypefn {GIMPLE function} bool is_gimple_val (tree t)
642 Returns true if t is a "GIMPLE value", which are all the
643 non-addressable stack variables (variables for which
644 @code{is_gimple_reg} returns true) and constants (expressions for which
645 @code{is_gimple_min_invariant} returns true).
646 @end deftypefn
648 @deftypefn {GIMPLE function} bool is_gimple_addressable (tree t)
649 Returns true if t is a symbol or memory reference whose address
650 can be taken.
651 @end deftypefn
653 @deftypefn {GIMPLE function} bool is_gimple_asm_val (tree t)
654 Similar to @code{is_gimple_val} but it also accepts hard registers.
655 @end deftypefn
657 @deftypefn {GIMPLE function} bool is_gimple_call_addr (tree t)
658 Return true if t is a valid expression to use as the function
659 called by a @code{GIMPLE_CALL}.
660 @end deftypefn
662 @deftypefn {GIMPLE function} bool is_gimple_mem_ref_addr (tree t)
663 Return true if t is a valid expression to use as first operand
664 of a @code{MEM_REF} expression.
665 @end deftypefn
667 @deftypefn {GIMPLE function} bool is_gimple_constant (tree t)
668 Return true if t is a valid gimple constant.
669 @end deftypefn
671 @deftypefn {GIMPLE function} bool is_gimple_min_invariant (tree t)
672 Return true if t is a valid minimal invariant.  This is different
673 from constants, in that the specific value of t may not be known
674 at compile time, but it is known that it doesn't change (e.g.,
675 the address of a function local variable).
676 @end deftypefn
678 @deftypefn {GIMPLE function} bool is_gimple_ip_invariant (tree t)
679 Return true if t is an interprocedural invariant.  This means that t
680 is a valid invariant in all functions (e.g. it can be an address of a
681 global variable but not of a local one).
682 @end deftypefn
684 @deftypefn {GIMPLE function} bool is_gimple_ip_invariant_address (tree t)
685 Return true if t is an @code{ADDR_EXPR} that does not change once the
686 program is running (and which is valid in all functions).
687 @end deftypefn
690 @subsection Statement validation
692 @deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
693 Return true if the code of g is @code{GIMPLE_ASSIGN}.
694 @end deftypefn
696 @deftypefn {GIMPLE function} bool is_gimple_call (gimple g)
697 Return true if the code of g is @code{GIMPLE_CALL}.
698 @end deftypefn
700 @deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)
701 Return true if the code of g is @code{GIMPLE_DEBUG}.
702 @end deftypefn
704 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple g)
705 Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
706 operation.
707 @end deftypefn
709 @deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g)
710 Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
711 expression to a variable.
712 @end deftypefn
714 @deftypefn {GIMPLE function} bool is_gimple_omp (gimple g)
715 Return true if g is any of the OpenMP codes.
716 @end deftypefn
718 @node Manipulating GIMPLE statements
719 @section Manipulating GIMPLE statements
720 @cindex Manipulating GIMPLE statements
722 This section documents all the functions available to handle each
723 of the GIMPLE instructions.
725 @subsection Common accessors
726 The following are common accessors for gimple statements.
728 @deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
729 Return the code for statement @code{G}.
730 @end deftypefn
732 @deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
733 Return the basic block to which statement @code{G} belongs to.
734 @end deftypefn
736 @deftypefn {GIMPLE function} tree gimple_block (gimple g)
737 Return the lexical scope block holding statement @code{G}.
738 @end deftypefn
740 @deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
741 Return the type of the main expression computed by @code{STMT}. Return
742 @code{void_type_node} if @code{STMT} computes nothing. This will only return
743 something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
744 @code{GIMPLE_CALL}.  For all other tuple codes, it will return
745 @code{void_type_node}.
746 @end deftypefn
748 @deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
749 Return the tree code for the expression computed by @code{STMT}.  This
750 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
751 @code{GIMPLE_COND}.  If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
752 For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
753 For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
754 by the @code{RHS} of the assignment.
755 @end deftypefn
757 @deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
758 Set the lexical scope block of @code{G} to @code{BLOCK}.
759 @end deftypefn
761 @deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
762 Return locus information for statement @code{G}.
763 @end deftypefn
765 @deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
766 Set locus information for statement @code{G}.
767 @end deftypefn
769 @deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
770 Return true if @code{G} does not have locus information.
771 @end deftypefn
773 @deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
774 Return true if no warnings should be emitted for statement @code{STMT}.
775 @end deftypefn
777 @deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
778 Set the visited status on statement @code{STMT} to @code{VISITED_P}.
779 @end deftypefn
781 @deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
782 Return the visited status on statement @code{STMT}.
783 @end deftypefn
785 @deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
786 Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
787 @end deftypefn
789 @deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
790 Return the value of pass local flag @code{PLF} on statement @code{STMT}.
791 @end deftypefn
793 @deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
794 Return true if statement @code{G} has register or memory operands.
795 @end deftypefn
797 @deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
798 Return true if statement @code{G} has memory operands.
799 @end deftypefn
801 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
802 Return the number of operands for statement @code{G}.
803 @end deftypefn
805 @deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
806 Return the array of operands for statement @code{G}.
807 @end deftypefn
809 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
810 Return operand @code{I} for statement @code{G}.
811 @end deftypefn
813 @deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
814 Return a pointer to operand @code{I} for statement @code{G}.
815 @end deftypefn
817 @deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
818 Set operand @code{I} of statement @code{G} to @code{OP}.
819 @end deftypefn
821 @deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
822 Return the set of symbols that have had their address taken by
823 @code{STMT}.
824 @end deftypefn
826 @deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
827 Return the set of @code{DEF} operands for statement @code{G}.
828 @end deftypefn
830 @deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
831 Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
832 @end deftypefn
834 @deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
835 Return the set of @code{USE} operands for statement @code{G}.
836 @end deftypefn
838 @deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
839 Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
840 @end deftypefn
842 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
843 Return the set of @code{VUSE} operands for statement @code{G}.
844 @end deftypefn
846 @deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
847 Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
848 @end deftypefn
850 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
851 Return the set of @code{VDEF} operands for statement @code{G}.
852 @end deftypefn
854 @deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
855 Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
856 @end deftypefn
858 @deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
859 Return the set of symbols loaded by statement @code{G}.  Each element of
860 the set is the @code{DECL_UID} of the corresponding symbol.
861 @end deftypefn
863 @deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
864 Return the set of symbols stored by statement @code{G}.  Each element of
865 the set is the @code{DECL_UID} of the corresponding symbol.
866 @end deftypefn
868 @deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
869 Return true if statement @code{G} has operands and the modified field
870 has been set.
871 @end deftypefn
873 @deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
874 Return true if statement @code{STMT} contains volatile operands.
875 @end deftypefn
877 @deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
878 Return true if statement @code{STMT} contains volatile operands.
879 @end deftypefn
881 @deftypefn {GIMPLE function} void update_stmt (gimple s)
882 Mark statement @code{S} as modified, and update it.
883 @end deftypefn
885 @deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
886 Update statement @code{S} if it has been marked modified.
887 @end deftypefn
889 @deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
890 Return a deep copy of statement @code{STMT}.
891 @end deftypefn
893 @node Tuple specific accessors
894 @section Tuple specific accessors
895 @cindex Tuple specific accessors
897 @menu
898 * @code{GIMPLE_ASM}::
899 * @code{GIMPLE_ASSIGN}::
900 * @code{GIMPLE_BIND}::
901 * @code{GIMPLE_CALL}::
902 * @code{GIMPLE_CATCH}::
903 * @code{GIMPLE_COND}::
904 * @code{GIMPLE_DEBUG}::
905 * @code{GIMPLE_EH_FILTER}::
906 * @code{GIMPLE_LABEL}::
907 * @code{GIMPLE_NOP}::
908 * @code{GIMPLE_OMP_ATOMIC_LOAD}::
909 * @code{GIMPLE_OMP_ATOMIC_STORE}::
910 * @code{GIMPLE_OMP_CONTINUE}::
911 * @code{GIMPLE_OMP_CRITICAL}::
912 * @code{GIMPLE_OMP_FOR}::
913 * @code{GIMPLE_OMP_MASTER}::
914 * @code{GIMPLE_OMP_ORDERED}::
915 * @code{GIMPLE_OMP_PARALLEL}::
916 * @code{GIMPLE_OMP_RETURN}::
917 * @code{GIMPLE_OMP_SECTION}::
918 * @code{GIMPLE_OMP_SECTIONS}::
919 * @code{GIMPLE_OMP_SINGLE}::
920 * @code{GIMPLE_PHI}::
921 * @code{GIMPLE_RESX}::
922 * @code{GIMPLE_RETURN}::
923 * @code{GIMPLE_SWITCH}::
924 * @code{GIMPLE_TRY}::
925 * @code{GIMPLE_WITH_CLEANUP_EXPR}::
926 @end menu
929 @node @code{GIMPLE_ASM}
930 @subsection @code{GIMPLE_ASM}
931 @cindex @code{GIMPLE_ASM}
933 @deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
934 Build a @code{GIMPLE_ASM} statement.  This statement is used for
935 building in-line assembly constructs.  @code{STRING} is the assembly
936 code.  @code{NINPUT} is the number of register inputs.  @code{NOUTPUT} is the
937 number of register outputs.  @code{NCLOBBERS} is the number of clobbered
938 registers.  The rest of the arguments trees for each input,
939 output, and clobbered registers.
940 @end deftypefn
942 @deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
943 Identical to gimple_build_asm, but the arguments are passed in
944 VECs.
945 @end deftypefn
947 @deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g)
948 Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
949 @end deftypefn
951 @deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g)
952 Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
953 @end deftypefn
955 @deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g)
956 Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
957 @end deftypefn
959 @deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
960 Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
961 @end deftypefn
963 @deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
964 Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
965 @end deftypefn
967 @deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
968 Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
969 @end deftypefn
971 @deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
972 unsigned index, tree out_op)
973 Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
974 @end deftypefn
976 @deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
977 Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
978 @end deftypefn
980 @deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
981 Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
982 @end deftypefn
984 @deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple g)
985 Return the string representing the assembly instruction in
986 @code{GIMPLE_ASM} @code{G}.
987 @end deftypefn
989 @deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
990 Return true if @code{G} is an asm statement marked volatile.
991 @end deftypefn
993 @deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
994 Mark asm statement @code{G} as volatile.
995 @end deftypefn
997 @deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
998 Remove volatile marker from asm statement @code{G}.
999 @end deftypefn
1001 @node @code{GIMPLE_ASSIGN}
1002 @subsection @code{GIMPLE_ASSIGN}
1003 @cindex @code{GIMPLE_ASSIGN}
1005 @deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
1006 Build a @code{GIMPLE_ASSIGN} statement.  The left-hand side is an lvalue
1007 passed in lhs.  The right-hand side can be either a unary or
1008 binary tree expression.  The expression tree rhs will be
1009 flattened and its operands assigned to the corresponding operand
1010 slots in the new statement.  This function is useful when you
1011 already have a tree expression that you want to convert into a
1012 tuple.  However, try to avoid building expression trees for the
1013 sole purpose of calling this function.  If you already have the
1014 operands in separate trees, it is better to use
1015 @code{gimple_build_assign_with_ops}.
1016 @end deftypefn
1019 @deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
1020 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
1021 @code{*SEQ_P}.
1022 @end deftypefn
1024 @code{DST}/@code{SRC} are the destination and source respectively.  You can
1025 pass ungimplified trees in @code{DST} or @code{SRC}, in which
1026 case they will be converted to a gimple operand if necessary.
1028 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
1030 @deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
1031 (enum tree_code subcode, tree lhs, tree op1, tree op2)
1032 This function is similar to @code{gimple_build_assign}, but is used to
1033 build a @code{GIMPLE_ASSIGN} statement when the operands of the
1034 right-hand side of the assignment are already split into
1035 different operands.
1037 The left-hand side is an lvalue passed in lhs.  Subcode is the
1038 @code{tree_code} for the right-hand side of the assignment.  Op1 and op2
1039 are the operands.  If op2 is null, subcode must be a @code{tree_code}
1040 for a unary expression.
1041 @end deftypefn
1043 @deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
1044 Return the code of the expression computed on the @code{RHS} of
1045 assignment statement @code{G}.
1046 @end deftypefn
1049 @deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
1050 Return the gimple rhs class of the code for the expression
1051 computed on the rhs of assignment statement @code{G}.  This will never
1052 return @code{GIMPLE_INVALID_RHS}.
1053 @end deftypefn
1055 @deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
1056 Return the @code{LHS} of assignment statement @code{G}.
1057 @end deftypefn
1059 @deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
1060 Return a pointer to the @code{LHS} of assignment statement @code{G}.
1061 @end deftypefn
1063 @deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
1064 Return the first operand on the @code{RHS} of assignment statement @code{G}.
1065 @end deftypefn
1067 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
1068 Return the address of the first operand on the @code{RHS} of assignment
1069 statement @code{G}.
1070 @end deftypefn
1072 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
1073 Return the second operand on the @code{RHS} of assignment statement @code{G}.
1074 @end deftypefn
1076 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
1077 Return the address of the second operand on the @code{RHS} of assignment
1078 statement @code{G}.
1079 @end deftypefn
1081 @deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
1082 Return the third operand on the @code{RHS} of assignment statement @code{G}.
1083 @end deftypefn
1085 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
1086 Return the address of the third operand on the @code{RHS} of assignment
1087 statement @code{G}.
1088 @end deftypefn
1090 @deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
1091 Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
1092 @end deftypefn
1094 @deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
1095 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
1096 statement @code{G}.
1097 @end deftypefn
1099 @deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
1100 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
1101 statement @code{G}.
1102 @end deftypefn
1104 @deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
1105 Set @code{RHS} to be the third operand on the @code{RHS} of assignment
1106 statement @code{G}.
1107 @end deftypefn
1109 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
1110 Return true if @code{S} is a type-cast assignment.
1111 @end deftypefn
1114 @node @code{GIMPLE_BIND}
1115 @subsection @code{GIMPLE_BIND}
1116 @cindex @code{GIMPLE_BIND}
1118 @deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
1119 Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
1120 and a body of statements in sequence @code{BODY}.
1121 @end deftypefn
1123 @deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
1124 Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
1125 @end deftypefn
1127 @deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
1128 Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
1129 statement @code{G}.
1130 @end deftypefn
1132 @deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
1133 Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
1134 statement @code{G}.
1135 @end deftypefn
1137 @deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
1138 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
1139 @code{G}.
1140 @end deftypefn
1142 @deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
1143 Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
1144 @end deftypefn
1146 @deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
1147 Append a statement to the end of a @code{GIMPLE_BIND}'s body.
1148 @end deftypefn
1150 @deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
1151 Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
1152 body.
1153 @end deftypefn
1155 @deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
1156 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
1157 @code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
1158 @end deftypefn
1160 @deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
1161 Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
1162 statement @code{G}.
1163 @end deftypefn
1166 @node @code{GIMPLE_CALL}
1167 @subsection @code{GIMPLE_CALL}
1168 @cindex @code{GIMPLE_CALL}
1170 @deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
1171 Build a @code{GIMPLE_CALL} statement to function @code{FN}.  The argument @code{FN}
1172 must be either a @code{FUNCTION_DECL} or a gimple call address as
1173 determined by @code{is_gimple_call_addr}.  @code{NARGS} are the number of
1174 arguments.  The rest of the arguments follow the argument @code{NARGS},
1175 and must be trees that are valid as rvalues in gimple (i.e., each
1176 operand is validated with @code{is_gimple_operand}).
1177 @end deftypefn
1180 @deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
1181 Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node.  The arguments and the
1182 function are taken from the expression directly.  This routine
1183 assumes that @code{call_expr} is already in GIMPLE form.  That is, its
1184 operands are GIMPLE values and the function call needs no further
1185 simplification.  All the call flags in @code{call_expr} are copied over
1186 to the new @code{GIMPLE_CALL}.
1187 @end deftypefn
1189 @deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
1190 Identical to @code{gimple_build_call} but the arguments are stored in a
1191 @code{VEC}().
1192 @end deftypefn
1194 @deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
1195 Return the @code{LHS} of call statement @code{G}.
1196 @end deftypefn
1198 @deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
1199 Return a pointer to the @code{LHS} of call statement @code{G}.
1200 @end deftypefn
1202 @deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
1203 Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
1204 @end deftypefn
1206 @deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
1207 Return the tree node representing the function called by call
1208 statement @code{G}.
1209 @end deftypefn
1211 @deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
1212 Set @code{FN} to be the function called by call statement @code{G}.  This has
1213 to be a gimple value specifying the address of the called
1214 function.
1215 @end deftypefn
1217 @deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
1218 If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
1219 Otherwise return @code{NULL}.  This function is analogous to
1220 @code{get_callee_fndecl} in @code{GENERIC}.
1221 @end deftypefn
1223 @deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
1224 Set the called function to @code{FNDECL}.
1225 @end deftypefn
1227 @deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
1228 Return the type returned by call statement @code{G}.
1229 @end deftypefn
1231 @deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
1232 Return the static chain for call statement @code{G}.
1233 @end deftypefn
1235 @deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
1236 Set @code{CHAIN} to be the static chain for call statement @code{G}.
1237 @end deftypefn
1239 @deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
1240 Return the number of arguments used by call statement @code{G}.
1241 @end deftypefn
1243 @deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
1244 Return the argument at position @code{INDEX} for call statement @code{G}.  The
1245 first argument is 0.
1246 @end deftypefn
1248 @deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
1249 Return a pointer to the argument at position @code{INDEX} for call
1250 statement @code{G}.
1251 @end deftypefn
1253 @deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
1254 Set @code{ARG} to be the argument at position @code{INDEX} for call statement
1255 @code{G}.
1256 @end deftypefn
1258 @deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
1259 Mark call statement @code{S} as being a tail call (i.e., a call just
1260 before the exit of a function). These calls are candidate for
1261 tail call optimization.
1262 @end deftypefn
1264 @deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
1265 Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
1266 @end deftypefn
1268 @deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
1269 Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
1270 @end deftypefn
1272 @deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
1273 Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
1274 @end deftypefn
1276 @deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
1277 Return true if @code{S} is a noreturn call.
1278 @end deftypefn
1280 @deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
1281 Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
1282 in the positions marked by the set @code{ARGS_TO_SKIP}.
1283 @end deftypefn
1286 @node @code{GIMPLE_CATCH}
1287 @subsection @code{GIMPLE_CATCH}
1288 @cindex @code{GIMPLE_CATCH}
1290 @deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
1291 Build a @code{GIMPLE_CATCH} statement.  @code{TYPES} are the tree types this
1292 catch handles.  @code{HANDLER} is a sequence of statements with the code
1293 for the handler.
1294 @end deftypefn
1296 @deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
1297 Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
1298 @end deftypefn
1300 @deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple g)
1301 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
1302 @code{G}.
1303 @end deftypefn
1305 @deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
1306 Return the GIMPLE sequence representing the body of the handler
1307 of @code{GIMPLE_CATCH} statement @code{G}.
1308 @end deftypefn
1310 @deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
1311 Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
1312 @end deftypefn
1314 @deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
1315 Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
1316 @end deftypefn
1319 @node @code{GIMPLE_COND}
1320 @subsection @code{GIMPLE_COND}
1321 @cindex @code{GIMPLE_COND}
1323 @deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
1324 Build a @code{GIMPLE_COND} statement.  @code{A} @code{GIMPLE_COND} statement compares
1325 @code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
1326 the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
1327 @code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
1328 @code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
1329 @end deftypefn
1332 @deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
1333 Build a @code{GIMPLE_COND} statement from the conditional expression
1334 tree @code{COND}.  @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
1335 @end deftypefn
1337 @deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
1338 Return the code of the predicate computed by conditional
1339 statement @code{G}.
1340 @end deftypefn
1342 @deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
1343 Set @code{CODE} to be the predicate code for the conditional statement
1344 @code{G}.
1345 @end deftypefn
1347 @deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
1348 Return the @code{LHS} of the predicate computed by conditional statement
1349 @code{G}.
1350 @end deftypefn
1352 @deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
1353 Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
1354 conditional statement @code{G}.
1355 @end deftypefn
1357 @deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
1358 Return the @code{RHS} operand of the predicate computed by conditional
1359 @code{G}.
1360 @end deftypefn
1362 @deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
1363 Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
1364 conditional statement @code{G}.
1365 @end deftypefn
1367 @deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
1368 Return the label used by conditional statement @code{G} when its
1369 predicate evaluates to true.
1370 @end deftypefn
1372 @deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
1373 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1374 its predicate evaluates to true.
1375 @end deftypefn
1377 @deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
1378 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1379 its predicate evaluates to false.
1380 @end deftypefn
1382 @deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
1383 Return the label used by conditional statement @code{G} when its
1384 predicate evaluates to false.
1385 @end deftypefn
1387 @deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
1388 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
1389 @end deftypefn
1391 @deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
1392 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
1393 @end deftypefn
1395 @node @code{GIMPLE_DEBUG}
1396 @subsection @code{GIMPLE_DEBUG}
1397 @cindex @code{GIMPLE_DEBUG}
1398 @cindex @code{GIMPLE_DEBUG_BIND}
1400 @deftypefn {GIMPLE function} gimple gimple_build_debug_bind (tree var, tree value, gimple stmt)
1401 Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of
1402 @code{subcode}.  The effect of this statement is to tell debug
1403 information generation machinery that the value of user variable
1404 @code{var} is given by @code{value} at that point, and to remain with
1405 that value until @code{var} runs out of scope, a
1406 dynamically-subsequent debug bind statement overrides the binding, or
1407 conflicting values reach a control flow merge point.  Even if
1408 components of the @code{value} expression change afterwards, the
1409 variable is supposed to retain the same value, though not necessarily
1410 the same location.
1412 It is expected that @code{var} be most often a tree for automatic user
1413 variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the
1414 requirements for gimple registers, but it may also be a tree for a
1415 scalarized component of a user variable (@code{ARRAY_REF},
1416 @code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}).
1418 As for @code{value}, it can be an arbitrary tree expression, but it is
1419 recommended that it be in a suitable form for a gimple assignment
1420 @code{RHS}.  It is not expected that user variables that could appear
1421 as @code{var} ever appear in @code{value}, because in the latter we'd
1422 have their @code{SSA_NAME}s instead, but even if they were not in SSA
1423 form, user variables appearing in @code{value} are to be regarded as
1424 part of the executable code space, whereas those in @code{var} are to
1425 be regarded as part of the source code space.  There is no way to
1426 refer to the value bound to a user variable within a @code{value}
1427 expression.
1429 If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
1430 generation machinery is informed that the variable @code{var} is
1431 unbound, i.e., that its value is indeterminate, which sometimes means
1432 it is really unavailable, and other times that the compiler could not
1433 keep track of it.
1435 Block and location information for the newly-created stmt are
1436 taken from @code{stmt}, if given.
1437 @end deftypefn
1439 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
1440 Return the user variable @var{var} that is bound at @code{stmt}.
1441 @end deftypefn
1443 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
1444 Return the value expression that is bound to a user variable at
1445 @code{stmt}.
1446 @end deftypefn
1448 @deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt)
1449 Return a pointer to the value expression that is bound to a user
1450 variable at @code{stmt}.
1451 @end deftypefn
1453 @deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
1454 Modify the user variable bound at @code{stmt} to @var{var}.
1455 @end deftypefn
1457 @deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
1458 Modify the value bound to the user variable bound at @code{stmt} to
1459 @var{value}.
1460 @end deftypefn
1462 @deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
1463 Modify the value bound to the user variable bound at @code{stmt} so
1464 that the variable becomes unbound.
1465 @end deftypefn
1467 @deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
1468 Return @code{TRUE} if @code{stmt} binds a user variable to a value,
1469 and @code{FALSE} if it unbinds the variable.
1470 @end deftypefn
1472 @node @code{GIMPLE_EH_FILTER}
1473 @subsection @code{GIMPLE_EH_FILTER}
1474 @cindex @code{GIMPLE_EH_FILTER}
1476 @deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
1477 Build a @code{GIMPLE_EH_FILTER} statement.  @code{TYPES} are the filter's
1478 types.  @code{FAILURE} is a sequence with the filter's failure action.
1479 @end deftypefn
1481 @deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
1482 Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
1483 @end deftypefn
1485 @deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
1486 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
1487 statement @code{G}.
1488 @end deftypefn
1490 @deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
1491 Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
1492 statement fails.
1493 @end deftypefn
1495 @deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
1496 Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
1497 @end deftypefn
1499 @deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
1500 Set @code{FAILURE} to be the sequence of statements to execute on
1501 failure for @code{GIMPLE_EH_FILTER} @code{G}.
1502 @end deftypefn
1504 @deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
1505 Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
1506 @end deftypefn
1508 @deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
1509 Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
1510 @end deftypefn
1513 @node @code{GIMPLE_LABEL}
1514 @subsection @code{GIMPLE_LABEL}
1515 @cindex @code{GIMPLE_LABEL}
1517 @deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
1518 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
1519 label, @code{LABEL}.
1520 @end deftypefn
1522 @deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
1523 Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
1524 @end deftypefn
1526 @deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
1527 Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
1528 statement @code{G}.
1529 @end deftypefn
1532 @deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
1533 Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
1534 @end deftypefn
1536 @deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
1537 Return the destination of the unconditional jump @code{G}.
1538 @end deftypefn
1540 @deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
1541 Set @code{DEST} to be the destination of the unconditional jump @code{G}.
1542 @end deftypefn
1545 @node @code{GIMPLE_NOP}
1546 @subsection @code{GIMPLE_NOP}
1547 @cindex @code{GIMPLE_NOP}
1549 @deftypefn {GIMPLE function} gimple gimple_build_nop (void)
1550 Build a @code{GIMPLE_NOP} statement.
1551 @end deftypefn
1553 @deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
1554 Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
1555 @end deftypefn
1557 @node @code{GIMPLE_OMP_ATOMIC_LOAD}
1558 @subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
1559 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
1561 @deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
1562 Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement.  @code{LHS} is the left-hand
1563 side of the assignment.  @code{RHS} is the right-hand side of the
1564 assignment.
1565 @end deftypefn
1567 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
1568 Set the @code{LHS} of an atomic load.
1569 @end deftypefn
1571 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
1572 Get the @code{LHS} of an atomic load.
1573 @end deftypefn
1575 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
1576 Set the @code{RHS} of an atomic set.
1577 @end deftypefn
1579 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
1580 Get the @code{RHS} of an atomic set.
1581 @end deftypefn
1584 @node @code{GIMPLE_OMP_ATOMIC_STORE}
1585 @subsection @code{GIMPLE_OMP_ATOMIC_STORE}
1586 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
1588 @deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
1589 Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
1590 stored.
1591 @end deftypefn
1593 @deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
1594 Set the value being stored in an atomic store.
1595 @end deftypefn
1597 @deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
1598 Return the value being stored in an atomic store.
1599 @end deftypefn
1601 @node @code{GIMPLE_OMP_CONTINUE}
1602 @subsection @code{GIMPLE_OMP_CONTINUE}
1603 @cindex @code{GIMPLE_OMP_CONTINUE}
1605 @deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
1606 Build a @code{GIMPLE_OMP_CONTINUE} statement.  @code{CONTROL_DEF} is the
1607 definition of the control variable.  @code{CONTROL_USE} is the use of
1608 the control variable.
1609 @end deftypefn
1611 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
1612 Return the definition of the control variable on a
1613 @code{GIMPLE_OMP_CONTINUE} in @code{S}.
1614 @end deftypefn
1616 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
1617 Same as above, but return the pointer.
1618 @end deftypefn
1620 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
1621 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
1622 statement in @code{S}.
1623 @end deftypefn
1625 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
1626 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
1627 in @code{S}.
1628 @end deftypefn
1630 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
1631 Same as above, but return the pointer.
1632 @end deftypefn
1634 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
1635 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
1636 in @code{S}.
1637 @end deftypefn
1640 @node @code{GIMPLE_OMP_CRITICAL}
1641 @subsection @code{GIMPLE_OMP_CRITICAL}
1642 @cindex @code{GIMPLE_OMP_CRITICAL}
1644 @deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
1645 Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
1646 statements for which only one thread can execute.  @code{NAME} is an
1647 optional identifier for this critical block.
1648 @end deftypefn
1650 @deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
1651 Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
1652 @end deftypefn
1654 @deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (gimple g)
1655 Return a pointer to the name associated with @code{OMP} critical
1656 statement @code{G}.
1657 @end deftypefn
1659 @deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
1660 Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
1661 @end deftypefn
1663 @node @code{GIMPLE_OMP_FOR}
1664 @subsection @code{GIMPLE_OMP_FOR}
1665 @cindex @code{GIMPLE_OMP_FOR}
1667 @deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
1668 tree clauses, tree index, tree initial, tree final, tree incr, @
1669 gimple_seq pre_body, enum tree_code omp_for_cond)
1670 Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
1671 inside the for loop.  @code{CLAUSES}, are any of the @code{OMP} loop
1672 construct's clauses: private, firstprivate,  lastprivate,
1673 reductions, ordered, schedule, and nowait.  @code{PRE_BODY} is the
1674 sequence of statements that are loop invariant.  @code{INDEX} is the
1675 index variable.  @code{INITIAL} is the initial value of @code{INDEX}.  @code{FINAL} is
1676 final value of @code{INDEX}.  OMP_FOR_COND is the predicate used to
1677 compare @code{INDEX} and @code{FINAL}.  @code{INCR} is the increment expression.
1678 @end deftypefn
1680 @deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
1681 Return the clauses associated with @code{OMP_FOR} @code{G}.
1682 @end deftypefn
1684 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
1685 Return a pointer to the @code{OMP_FOR} @code{G}.
1686 @end deftypefn
1688 @deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
1689 Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
1690 @end deftypefn
1692 @deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
1693 Return the index variable for @code{OMP_FOR} @code{G}.
1694 @end deftypefn
1696 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
1697 Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
1698 @end deftypefn
1700 @deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
1701 Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
1702 @end deftypefn
1704 @deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
1705 Return the initial value for @code{OMP_FOR} @code{G}.
1706 @end deftypefn
1708 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
1709 Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
1710 @end deftypefn
1712 @deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
1713 Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
1714 @end deftypefn
1716 @deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
1717 Return the final value for @code{OMP_FOR} @code{G}.
1718 @end deftypefn
1720 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
1721 turn a pointer to the final value for @code{OMP_FOR} @code{G}.
1722 @end deftypefn
1724 @deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
1725 Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
1726 @end deftypefn
1728 @deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
1729 Return the increment value for @code{OMP_FOR} @code{G}.
1730 @end deftypefn
1732 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
1733 Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
1734 @end deftypefn
1736 @deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
1737 Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
1738 @end deftypefn
1740 @deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
1741 Return the sequence of statements to execute before the @code{OMP_FOR}
1742 statement @code{G} starts.
1743 @end deftypefn
1745 @deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
1746 Set @code{PRE_BODY} to be the sequence of statements to execute before
1747 the @code{OMP_FOR} statement @code{G} starts.
1748 @end deftypefn
1750 @deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
1751 Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
1752 @end deftypefn
1754 @deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
1755 Return the condition code associated with @code{OMP_FOR} @code{G}.
1756 @end deftypefn
1759 @node @code{GIMPLE_OMP_MASTER}
1760 @subsection @code{GIMPLE_OMP_MASTER}
1761 @cindex @code{GIMPLE_OMP_MASTER}
1763 @deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
1764 Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
1765 statements to be executed by just the master.
1766 @end deftypefn
1769 @node @code{GIMPLE_OMP_ORDERED}
1770 @subsection @code{GIMPLE_OMP_ORDERED}
1771 @cindex @code{GIMPLE_OMP_ORDERED}
1773 @deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
1774 Build a @code{GIMPLE_OMP_ORDERED} statement.
1775 @end deftypefn
1777 @code{BODY} is the sequence of statements inside a loop that will
1778 executed in sequence.
1781 @node @code{GIMPLE_OMP_PARALLEL}
1782 @subsection @code{GIMPLE_OMP_PARALLEL}
1783 @cindex @code{GIMPLE_OMP_PARALLEL}
1785 @deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq @
1786 body, tree clauses, tree child_fn, tree data_arg)
1787 Build a @code{GIMPLE_OMP_PARALLEL} statement.
1788 @end deftypefn
1790 @code{BODY} is sequence of statements which are executed in parallel.
1791 @code{CLAUSES}, are the @code{OMP} parallel construct's clauses.  @code{CHILD_FN} is
1792 the function created for the parallel threads to execute.
1793 @code{DATA_ARG} are the shared data argument(s).
1795 @deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
1796 Return true if @code{OMP} parallel statement @code{G} has the
1797 @code{GF_OMP_PARALLEL_COMBINED} flag set.
1798 @end deftypefn
1800 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
1801 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
1802 @code{G}.
1803 @end deftypefn
1805 @deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
1806 Return the body for the @code{OMP} statement @code{G}.
1807 @end deftypefn
1809 @deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
1810 Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
1811 @end deftypefn
1813 @deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
1814 Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
1815 @end deftypefn
1817 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (gimple g)
1818 Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
1819 @end deftypefn
1821 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
1822 Set @code{CLAUSES} to be the list of clauses associated with
1823 @code{OMP_PARALLEL} @code{G}.
1824 @end deftypefn
1826 @deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
1827 Return the child function used to hold the body of @code{OMP_PARALLEL}
1828 @code{G}.
1829 @end deftypefn
1831 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (gimple g)
1832 Return a pointer to the child function used to hold the body of
1833 @code{OMP_PARALLEL} @code{G}.
1834 @end deftypefn
1836 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
1837 Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
1838 @end deftypefn
1840 @deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
1841 Return the artificial argument used to send variables and values
1842 from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
1843 @end deftypefn
1845 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (gimple g)
1846 Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
1847 @end deftypefn
1849 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
1850 Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
1851 @end deftypefn
1854 @node @code{GIMPLE_OMP_RETURN}
1855 @subsection @code{GIMPLE_OMP_RETURN}
1856 @cindex @code{GIMPLE_OMP_RETURN}
1858 @deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
1859 Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
1860 non-waiting return.
1861 @end deftypefn
1863 @deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
1864 Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
1865 @end deftypefn
1868 @deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
1869 Return true if @code{OMP} return statement @code{G} has the
1870 @code{GF_OMP_RETURN_NOWAIT} flag set.
1871 @end deftypefn
1873 @node @code{GIMPLE_OMP_SECTION}
1874 @subsection @code{GIMPLE_OMP_SECTION}
1875 @cindex @code{GIMPLE_OMP_SECTION}
1877 @deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
1878 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
1879 @end deftypefn
1881 @code{BODY} is the sequence of statements in the section.
1883 @deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
1884 Return true if @code{OMP} section statement @code{G} has the
1885 @code{GF_OMP_SECTION_LAST} flag set.
1886 @end deftypefn
1888 @deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
1889 Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
1890 @end deftypefn
1892 @node @code{GIMPLE_OMP_SECTIONS}
1893 @subsection @code{GIMPLE_OMP_SECTIONS}
1894 @cindex @code{GIMPLE_OMP_SECTIONS}
1896 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
1897 Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
1898 section statements.  @code{CLAUSES} are any of the @code{OMP} sections
1899 construct's clauses: private, firstprivate, lastprivate,
1900 reduction, and nowait.
1901 @end deftypefn
1904 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
1905 Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
1906 @end deftypefn
1908 @deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
1909 Return the control variable associated with the
1910 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
1911 @end deftypefn
1913 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
1914 Return a pointer to the clauses associated with the
1915 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
1916 @end deftypefn
1918 @deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
1919 Set @code{CONTROL} to be the set of clauses associated with the
1920 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
1921 @end deftypefn
1923 @deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
1924 Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
1925 @end deftypefn
1927 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
1928 Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
1929 @end deftypefn
1931 @deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
1932 Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
1933 @code{G}.
1934 @end deftypefn
1937 @node @code{GIMPLE_OMP_SINGLE}
1938 @subsection @code{GIMPLE_OMP_SINGLE}
1939 @cindex @code{GIMPLE_OMP_SINGLE}
1941 @deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
1942 Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
1943 statements that will be executed once.  @code{CLAUSES} are any of the
1944 @code{OMP} single construct's clauses: private, firstprivate,
1945 copyprivate, nowait.
1946 @end deftypefn
1948 @deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
1949 Return the clauses associated with @code{OMP_SINGLE} @code{G}.
1950 @end deftypefn
1952 @deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
1953 Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
1954 @end deftypefn
1956 @deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
1957 Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
1958 @end deftypefn
1961 @node @code{GIMPLE_PHI}
1962 @subsection @code{GIMPLE_PHI}
1963 @cindex @code{GIMPLE_PHI}
1965 @deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
1966 Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
1967 @end deftypefn
1969 @deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
1970 Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
1971 be exactly the number of incoming edges for the basic block
1972 holding @code{G}.
1973 @end deftypefn
1975 @deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
1976 Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
1977 @end deftypefn
1979 @deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
1980 Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
1981 @end deftypefn
1983 @deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
1984 Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
1985 @end deftypefn
1987 @deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
1988 Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
1989 @code{GIMPLE_PHI} @code{G}.
1990 @end deftypefn
1992 @deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
1993 Set @code{PHIARG} to be the argument corresponding to incoming edge
1994 @code{INDEX} for @code{GIMPLE_PHI} @code{G}.
1995 @end deftypefn
1997 @node @code{GIMPLE_RESX}
1998 @subsection @code{GIMPLE_RESX}
1999 @cindex @code{GIMPLE_RESX}
2001 @deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
2002 Build a @code{GIMPLE_RESX} statement which is a statement.  This
2003 statement is a placeholder for _Unwind_Resume before we know if a
2004 function call or a branch is needed.  @code{REGION} is the exception
2005 region from which control is flowing.
2006 @end deftypefn
2008 @deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
2009 Return the region number for @code{GIMPLE_RESX} @code{G}.
2010 @end deftypefn
2012 @deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
2013 Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
2014 @end deftypefn
2016 @node @code{GIMPLE_RETURN}
2017 @subsection @code{GIMPLE_RETURN}
2018 @cindex @code{GIMPLE_RETURN}
2020 @deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
2021 Build a @code{GIMPLE_RETURN} statement whose return value is retval.
2022 @end deftypefn
2024 @deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
2025 Return the return value for @code{GIMPLE_RETURN} @code{G}.
2026 @end deftypefn
2028 @deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
2029 Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
2030 @end deftypefn
2032 @node @code{GIMPLE_SWITCH}
2033 @subsection @code{GIMPLE_SWITCH}
2034 @cindex @code{GIMPLE_SWITCH}
2036 @deftypefn {GIMPLE function} gimple gimple_build_switch (tree index, tree @
2037 default_label, @code{VEC}(tree,heap) *args)
2038 Build a @code{GIMPLE_SWITCH} statement.  @code{INDEX} is the index variable
2039 to switch on, and @code{DEFAULT_LABEL} represents the default label.
2040 @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
2041 non-default case labels.  Each label is a tree of code @code{CASE_LABEL_EXPR}.
2042 @end deftypefn
2044 @deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
2045 Return the number of labels associated with the switch statement
2046 @code{G}.
2047 @end deftypefn
2049 @deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, @
2050 unsigned nlabels)
2051 Set @code{NLABELS} to be the number of labels for the switch statement
2052 @code{G}.
2053 @end deftypefn
2055 @deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
2056 Return the index variable used by the switch statement @code{G}.
2057 @end deftypefn
2059 @deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
2060 Set @code{INDEX} to be the index variable for switch statement @code{G}.
2061 @end deftypefn
2063 @deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
2064 Return the label numbered @code{INDEX}. The default label is 0, followed
2065 by any labels in a switch statement.
2066 @end deftypefn
2068 @deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned @
2069 index, tree label)
2070 Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
2071 label.
2072 @end deftypefn
2074 @deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
2075 Return the default label for a switch statement.
2076 @end deftypefn
2078 @deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, @
2079 tree label)
2080 Set the default label for a switch statement.
2081 @end deftypefn
2084 @node @code{GIMPLE_TRY}
2085 @subsection @code{GIMPLE_TRY}
2086 @cindex @code{GIMPLE_TRY}
2088 @deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, @
2089 gimple_seq cleanup, unsigned int kind)
2090 Build a @code{GIMPLE_TRY} statement.  @code{EVAL} is a sequence with the
2091 expression to evaluate.  @code{CLEANUP} is a sequence of statements to
2092 run at clean-up time.  @code{KIND} is the enumeration value
2093 @code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
2094 or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
2095 construct.
2096 @end deftypefn
2098 @deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
2099 Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
2100 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
2101 @end deftypefn
2103 @deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
2104 Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2105 @end deftypefn
2107 @deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
2108 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
2109 @code{G}.
2110 @end deftypefn
2112 @deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
2113 Return the sequence of statements used as the cleanup body for
2114 @code{GIMPLE_TRY} @code{G}.
2115 @end deftypefn
2117 @deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
2118 bool catch_is_cleanup)
2119 Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2120 @end deftypefn
2122 @deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
2123 Set @code{EVAL} to be the sequence of statements to use as the body for
2124 @code{GIMPLE_TRY} @code{G}.
2125 @end deftypefn
2127 @deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
2128 Set @code{CLEANUP} to be the sequence of statements to use as the
2129 cleanup body for @code{GIMPLE_TRY} @code{G}.
2130 @end deftypefn
2132 @node @code{GIMPLE_WITH_CLEANUP_EXPR}
2133 @subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
2134 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
2136 @deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
2137 Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @code{CLEANUP} is the
2138 clean-up expression.
2139 @end deftypefn
2141 @deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
2142 Return the cleanup sequence for cleanup statement @code{G}.
2143 @end deftypefn
2145 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
2146 Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
2147 @end deftypefn
2149 @deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
2150 Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2151 @end deftypefn
2153 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
2154 Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2155 @end deftypefn
2158 @node GIMPLE sequences
2159 @section GIMPLE sequences
2160 @cindex GIMPLE sequences
2162 GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
2163 used in @code{GENERIC}.  They are used to chain statements together, and
2164 when used in conjunction with sequence iterators, provide a
2165 framework for iterating through statements.
2167 GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
2168 commonly passed by reference to functions dealing with sequences.
2169 The type for a sequence pointer is @code{gimple_seq} which is the same
2170 as struct @code{gimple_sequence} *.  When declaring a local sequence,
2171 you can define a local variable of type struct @code{gimple_sequence}.
2172 When declaring a sequence allocated on the garbage collected
2173 heap, use the function @code{gimple_seq_alloc} documented below.
2175 There are convenience functions for iterating through sequences
2176 in the section entitled Sequence Iterators.
2178 Below is a list of functions to manipulate and query sequences.
2180 @deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
2181 Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
2182 not @code{NULL}.  If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
2183 @end deftypefn
2185 @deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
2186 Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
2187 @code{NULL}.  If *@code{DEST} is @code{NULL}, allocate a new sequence before
2188 appending.
2189 @end deftypefn
2191 @deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
2192 Perform a deep copy of sequence @code{SRC} and return the result.
2193 @end deftypefn
2195 @deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
2196 Reverse the order of the statements in the sequence @code{SEQ}.  Return
2197 @code{SEQ}.
2198 @end deftypefn
2200 @deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
2201 Return the first statement in sequence @code{S}.
2202 @end deftypefn
2204 @deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
2205 Return the last statement in sequence @code{S}.
2206 @end deftypefn
2208 @deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
2209 Set the last statement in sequence @code{S} to the statement in @code{LAST}.
2210 @end deftypefn
2212 @deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
2213 Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
2214 @end deftypefn
2216 @deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
2217 Initialize sequence @code{S} to an empty sequence.
2218 @end deftypefn
2220 @deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
2221 Allocate a new sequence in the garbage collected store and return
2223 @end deftypefn
2225 @deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
2226 Copy the sequence @code{SRC} into the sequence @code{DEST}.
2227 @end deftypefn
2229 @deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
2230 Return true if the sequence @code{S} is empty.
2231 @end deftypefn
2233 @deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
2234 Returns the sequence of statements in @code{BB}.
2235 @end deftypefn
2237 @deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
2238 Sets the sequence of statements in @code{BB} to @code{SEQ}.
2239 @end deftypefn
2241 @deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
2242 Determine whether @code{SEQ} contains exactly one statement.
2243 @end deftypefn
2245 @node Sequence iterators
2246 @section Sequence iterators
2247 @cindex Sequence iterators
2249 Sequence iterators are convenience constructs for iterating
2250 through statements in a sequence.  Given a sequence @code{SEQ}, here is
2251 a typical use of gimple sequence iterators:
2253 @smallexample
2254 gimple_stmt_iterator gsi;
2256 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
2257   @{
2258     gimple g = gsi_stmt (gsi);
2259     /* Do something with gimple statement @code{G}.  */
2260   @}
2261 @end smallexample
2263 Backward iterations are possible:
2265 @smallexample
2266         for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
2267 @end smallexample
2269 Forward and backward iterations on basic blocks are possible with
2270 @code{gsi_start_bb} and @code{gsi_last_bb}.
2272 In the documentation below we sometimes refer to enum
2273 @code{gsi_iterator_update}.  The valid options for this enumeration are:
2275 @itemize @bullet
2276 @item @code{GSI_NEW_STMT}
2277 Only valid when a single statement is added.  Move the iterator to it.
2279 @item @code{GSI_SAME_STMT}
2280 Leave the iterator at the same statement.
2282 @item @code{GSI_CONTINUE_LINKING}
2283 Move iterator to whatever position is suitable for linking other
2284 statements in the same direction.
2285 @end itemize
2287 Below is a list of the functions used to manipulate and use
2288 statement iterators.
2290 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
2291 Return a new iterator pointing to the sequence @code{SEQ}'s first
2292 statement.  If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
2293 Use @code{gsi_start_bb} instead when the iterator needs to always have
2294 the correct basic block set.
2295 @end deftypefn
2297 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
2298 Return a new iterator pointing to the first statement in basic
2299 block @code{BB}.
2300 @end deftypefn
2302 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
2303 Return a new iterator initially pointing to the last statement of
2304 sequence @code{SEQ}.  If @code{SEQ} is empty, the iterator's basic block is
2305 @code{NULL}.  Use @code{gsi_last_bb} instead when the iterator needs to always
2306 have the correct basic block set.
2307 @end deftypefn
2309 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
2310 Return a new iterator pointing to the last statement in basic
2311 block @code{BB}.
2312 @end deftypefn
2314 @deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
2315 Return @code{TRUE} if at the end of @code{I}.
2316 @end deftypefn
2318 @deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
2319 Return @code{TRUE} if we're one statement before the end of @code{I}.
2320 @end deftypefn
2322 @deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
2323 Advance the iterator to the next gimple statement.
2324 @end deftypefn
2326 @deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
2327 Advance the iterator to the previous gimple statement.
2328 @end deftypefn
2330 @deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
2331 Return the current stmt.
2332 @end deftypefn
2334 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb)
2335 Return a block statement iterator that points to the first
2336 non-label statement in block @code{BB}.
2337 @end deftypefn
2339 @deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i)
2340 Return a pointer to the current stmt.
2341 @end deftypefn
2343 @deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
2344 Return the basic block associated with this iterator.
2345 @end deftypefn
2347 @deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
2348 Return the sequence associated with this iterator.
2349 @end deftypefn
2351 @deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
2352 Remove the current stmt from the sequence.  The iterator is
2353 updated to point to the next statement.  When @code{REMOVE_EH_INFO} is
2354 true we remove the statement pointed to by iterator @code{I} from the @code{EH}
2355 tables.  Otherwise we do not modify the @code{EH} tables.  Generally,
2356 @code{REMOVE_EH_INFO} should be true when the statement is going to be
2357 removed from the @code{IL} and not reinserted elsewhere.
2358 @end deftypefn
2360 @deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2361 Links the sequence of statements @code{SEQ} before the statement pointed
2362 by iterator @code{I}.  @code{MODE} indicates what to do with the iterator
2363 after insertion (see @code{enum gsi_iterator_update} above).
2364 @end deftypefn
2366 @deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
2367 Links statement @code{G} before the statement pointed-to by iterator @code{I}.
2368 Updates iterator @code{I} according to @code{MODE}.
2369 @end deftypefn
2371 @deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, @
2372 gimple_seq seq, enum gsi_iterator_update mode)
2373 Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
2374 @code{MODE} is as in @code{gsi_insert_after}.
2375 @end deftypefn
2377 @deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
2378 gimple g, enum gsi_iterator_update mode)
2379 Links statement @code{G} after the statement pointed-to by iterator @code{I}.
2380 @code{MODE} is as in @code{gsi_insert_after}.
2381 @end deftypefn
2383 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
2384 Move all statements in the sequence after @code{I} to a new sequence.
2385 Return this new sequence.
2386 @end deftypefn
2388 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
2389 Move all statements in the sequence before @code{I} to a new sequence.
2390 Return this new sequence.
2391 @end deftypefn
2393 @deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @
2394 gimple stmt, bool update_eh_info)
2395 Replace the statement pointed-to by @code{I} to @code{STMT}.  If @code{UPDATE_EH_INFO}
2396 is true, the exception handling information of the original
2397 statement is moved to the new statement.
2398 @end deftypefn
2400 @deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
2401 gimple stmt, enum gsi_iterator_update mode)
2402 Insert statement @code{STMT} before the statement pointed-to by iterator
2403 @code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
2404 specifies how to update iterator @code{I} after insertion (see enum
2405 @code{gsi_iterator_update}).
2406 @end deftypefn
2408 @deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, @
2409 gimple_seq seq, enum gsi_iterator_update mode)
2410 Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
2411 @end deftypefn
2413 @deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
2414 gimple stmt, enum gsi_iterator_update mode)
2415 Insert statement @code{STMT} after the statement pointed-to by iterator
2416 @code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
2417 specifies how to update iterator @code{I} after insertion (see enum
2418 @code{gsi_iterator_update}).
2419 @end deftypefn
2421 @deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, @
2422 gimple_seq seq, enum gsi_iterator_update mode)
2423 Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
2424 @end deftypefn
2426 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
2427 Finds iterator for @code{STMT}.
2428 @end deftypefn
2430 @deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, @
2431 gimple_stmt_iterator *to)
2432 Move the statement at @code{FROM} so it comes right after the statement
2433 at @code{TO}.
2434 @end deftypefn
2436 @deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, @
2437 gimple_stmt_iterator *to)
2438 Move the statement at @code{FROM} so it comes right before the statement
2439 at @code{TO}.
2440 @end deftypefn
2442 @deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, @
2443 basic_block bb)
2444 Move the statement at @code{FROM} to the end of basic block @code{BB}.
2445 @end deftypefn
2447 @deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
2448 Add @code{STMT} to the pending list of edge @code{E}.  No actual insertion is
2449 made until a call to @code{gsi_commit_edge_inserts}() is made.
2450 @end deftypefn
2452 @deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
2453 Add the sequence of statements in @code{SEQ} to the pending list of edge
2454 @code{E}.  No actual insertion is made until a call to
2455 @code{gsi_commit_edge_inserts}() is made.
2456 @end deftypefn
2458 @deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
2459 Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}.  If a new
2460 block has to be created, it is returned.
2461 @end deftypefn
2463 @deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
2464 Commit insertions pending at edge @code{E}.  If a new block is created,
2465 set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
2466 @end deftypefn
2468 @deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
2469 This routine will commit all pending edge insertions, creating
2470 any new basic blocks which are necessary.
2471 @end deftypefn
2474 @node Adding a new GIMPLE statement code
2475 @section Adding a new GIMPLE statement code
2476 @cindex Adding a new GIMPLE statement code
2478 The first step in adding a new GIMPLE statement code, is
2479 modifying the file @code{gimple.def}, which contains all the GIMPLE
2480 codes.  Then you must add a corresponding structure, and an entry
2481 in @code{union gimple_statement_d}, both of which are located in
2482 @code{gimple.h}.  This in turn, will require you to add a corresponding
2483 @code{GTY} tag in @code{gsstruct.def}, and code to handle this tag in
2484 @code{gss_for_code} which is located in @code{gimple.c}.
2486 In order for the garbage collector to know the size of the
2487 structure you created in @code{gimple.h}, you need to add a case to
2488 handle your new GIMPLE statement in @code{gimple_size} which is located
2489 in @code{gimple.c}.
2491 You will probably want to create a function to build the new
2492 gimple statement in @code{gimple.c}.  The function should be called
2493 @code{gimple_build_@var{new-tuple-name}}, and should return the new tuple
2494 of type gimple.
2496 If your new statement requires accessors for any members or
2497 operands it may have, put simple inline accessors in
2498 @code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
2499 corresponding prototype in @code{gimple.h}.
2502 @node Statement and operand traversals
2503 @section Statement and operand traversals
2504 @cindex Statement and operand traversals
2506 There are two functions available for walking statements and
2507 sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
2508 accordingly, and a third function for walking the operands in a
2509 statement: @code{walk_gimple_op}.
2511 @deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, @
2512   walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2513 This function is used to walk the current statement in @code{GSI},
2514 optionally using traversal state stored in @code{WI}.  If @code{WI} is @code{NULL}, no
2515 state is kept during the traversal.
2517 The callback @code{CALLBACK_STMT} is called.  If @code{CALLBACK_STMT} returns
2518 true, it means that the callback function has handled all the
2519 operands of the statement and it is not necessary to walk its
2520 operands.
2522 If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
2523 called on each operand of the statement via @code{walk_gimple_op}.  If
2524 @code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
2525 operands are not scanned.
2527 The return value is that returned by the last call to
2528 @code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
2529 @end deftypefn
2532 @deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @
2533   walk_tree_fn callback_op, struct walk_stmt_info *wi)
2534 Use this function to walk the operands of statement @code{STMT}.  Every
2535 operand is walked via @code{walk_tree} with optional state information
2536 in @code{WI}.
2538 @code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
2539 Additional parameters to @code{walk_tree} must be stored in @code{WI}.  For
2540 each operand @code{OP}, @code{walk_tree} is called as:
2542 @smallexample
2543 walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{PSET})
2544 @end smallexample
2546 If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
2547 operands are not scanned.  The return value is that returned by
2548 the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
2549 specified.
2550 @end deftypefn
2553 @deftypefn {GIMPLE function} tree walk_gimple_seq (gimple_seq seq, @
2554   walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2555 This function walks all the statements in the sequence @code{SEQ}
2556 calling @code{walk_gimple_stmt} on each one.  @code{WI} is as in
2557 @code{walk_gimple_stmt}.  If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
2558 is stopped and the value returned.  Otherwise, all the statements
2559 are walked and @code{NULL_TREE} returned.
2560 @end deftypefn