Debian Codegraph @

gcc/doc/gimple.texi

raw
1 @c Copyright (C) 2008-2025 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.
5
6 @node GIMPLE
7 @chapter GIMPLE
8 @cindex GIMPLE
9
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}.
16
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.
22
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.
26
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.
35
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}.
40
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.
55
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@.
67
68 You can request to dump a C-like representation of the GIMPLE form
69 with the flag @option{-fdump-tree-gimple}.
70
71 @menu
72 * Tuple representation::
73 * Class hierarchy of GIMPLE statements::
74 * GIMPLE instruction set::
75 * GIMPLE Exception Handling::
76 * Temporaries::
77 * Operands::
78 * Manipulating GIMPLE statements::
79 * Tuple specific accessors::
80 * GIMPLE sequences::
81 * Sequence iterators::
82 * Adding a new GIMPLE statement code::
83 * Statement and operand traversals::
84 @end menu
85
86 @node Tuple representation
87 @section Tuple representation
88 @cindex tuples
89
90 GIMPLE instructions are tuples of variable size divided in two
91 groups: a header describing the instruction and its locations,
92 and a variable length body with all the operands. Tuples are
93 organized into a hierarchy with 3 main classes of tuples.
94
95 @subsection @code{gimple} (gsbase)
96 @cindex gimple
97
98 This is the root of the hierarchy, it holds basic information
99 needed by most GIMPLE statements. There are some fields that
100 may not be relevant to every GIMPLE statement, but those were
101 moved into the base structure to take advantage of holes left by
102 other fields (thus making the structure more compact). The
103 structure takes 4 words (32 bytes) on 64 bit hosts:
104
105 @multitable {@code{references_memory_p}} {Size (bits)}
106 @item Field @tab Size (bits)
107 @item @code{code} @tab 8
108 @item @code{subcode} @tab 16
109 @item @code{no_warning} @tab 1
110 @item @code{visited} @tab 1
111 @item @code{nontemporal_move} @tab 1
112 @item @code{plf} @tab 2
113 @item @code{modified} @tab 1
114 @item @code{has_volatile_ops} @tab 1
115 @item @code{references_memory_p} @tab 1
116 @item @code{uid} @tab 32
117 @item @code{location} @tab 32
118 @item @code{num_ops} @tab 32
119 @item @code{bb} @tab 64
120 @item @code{block} @tab 63
121 @item Total size @tab 32 bytes
122 @end multitable
123
124 @itemize @bullet
125 @item @code{code}
126 Main identifier for a GIMPLE instruction.
127
128 @item @code{subcode}
129 Used to distinguish different variants of the same basic
130 instruction or provide flags applicable to a given code. The
131 @code{subcode} flags field has different uses depending on the code of
132 the instruction, but mostly it distinguishes instructions of the
133 same family. The most prominent use of this field is in
134 assignments, where subcode indicates the operation done on the
135 RHS of the assignment. For example, a = b + c is encoded as
136 @code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.
137
138 @item @code{no_warning}
139 Bitflag to indicate whether a warning has already been issued on
140 this statement.
141
142 @item @code{visited}
143 General purpose ``visited'' marker. Set and cleared by each pass
144 when needed.
145
146 @item @code{nontemporal_move}
147 Bitflag used in assignments that represent non-temporal moves.
148 Although this bitflag is only used in assignments, it was moved
149 into the base to take advantage of the bit holes left by the
150 previous fields.
151
152 @item @code{plf}
153 Pass Local Flags. This 2-bit mask can be used as general purpose
154 markers by any pass. Passes are responsible for clearing and
155 setting these two flags accordingly.
156
157 @item @code{modified}
158 Bitflag to indicate whether the statement has been modified.
159 Used mainly by the operand scanner to determine when to re-scan a
160 statement for operands.
161
162 @item @code{has_volatile_ops}
163 Bitflag to indicate whether this statement contains operands that
164 have been marked volatile.
165
166 @item @code{references_memory_p}
167 Bitflag to indicate whether this statement contains memory
168 references (i.e., its operands are either global variables, or
169 pointer dereferences or anything that must reside in memory).
170
171 @item @code{uid}
172 This is an unsigned integer used by passes that want to assign
173 IDs to every statement. These IDs must be assigned and used by
174 each pass.
175
176 @item @code{location}
177 This is a @code{location_t} identifier to specify source code
178 location for this statement. It is inherited from the front
179 end.
180
181 @item @code{num_ops}
182 Number of operands that this statement has. This specifies the
183 size of the operand vector embedded in the tuple. Only used in
184 some tuples, but it is declared in the base tuple to take
185 advantage of the 32-bit hole left by the previous fields.
186
187 @item @code{bb}
188 Basic block holding the instruction.
189
190 @item @code{block}
191 Lexical block holding this statement. Also used for debug
192 information generation.
193 @end itemize
194
195 @subsection @code{gimple_statement_with_ops}
196 @cindex gimple_statement_with_ops
197
198 This tuple is actually split in two:
199 @code{gimple_statement_with_ops_base} and
200 @code{gimple_statement_with_ops}. This is needed to accommodate the
201 way the operand vector is allocated. The operand vector is
202 defined to be an array of 1 element. So, to allocate a dynamic
203 number of operands, the memory allocator (@code{gimple_alloc}) simply
204 allocates enough memory to hold the structure itself plus @code{N
205 - 1} operands which run ``off the end'' of the structure. For
206 example, to allocate space for a tuple with 3 operands,
207 @code{gimple_alloc} reserves @code{sizeof (struct
208 gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
209
210 On the other hand, several fields in this tuple need to be shared
211 with the @code{gimple_statement_with_memory_ops} tuple. So, these
212 common fields are placed in @code{gimple_statement_with_ops_base} which
213 is then inherited from the other two tuples.
214
215
216 @multitable {@code{def_ops}} {48 + 8 * @code{num_ops} bytes}
217 @item @code{gsbase} @tab 256
218 @item @code{def_ops} @tab 64
219 @item @code{use_ops} @tab 64
220 @item @code{op} @tab @code{num_ops} * 64
221 @item Total size @tab 48 + 8 * @code{num_ops} bytes
222 @end multitable
223
224 @itemize @bullet
225 @item @code{gsbase}
226 Inherited from @code{struct gimple}.
227
228 @item @code{def_ops}
229 Array of pointers into the operand array indicating all the slots that
230 contain a variable written-to by the statement. This array is
231 also used for immediate use chaining. Note that it would be
232 possible to not rely on this array, but the changes required to
233 implement this are pretty invasive.
234
235 @item @code{use_ops}
236 Similar to @code{def_ops} but for variables read by the statement.
237
238 @item @code{op}
239 Array of trees with @code{num_ops} slots.
240 @end itemize
241
242 @subsection @code{gimple_statement_with_memory_ops}
243
244 This tuple is essentially identical to @code{gimple_statement_with_ops},
245 except that it contains 4 additional fields to hold vectors
246 related memory stores and loads. Similar to the previous case,
247 the structure is split in two to accommodate for the operand
248 vector (@code{gimple_statement_with_memory_ops_base} and
249 @code{gimple_statement_with_memory_ops}).
250
251
252 @multitable {@code{vdef_ops}} {80 + 8 * @code{num_ops} bytes}
253 @item Field @tab Size (bits)
254 @item @code{gsbase} @tab 256
255 @item @code{def_ops} @tab 64
256 @item @code{use_ops} @tab 64
257 @item @code{vdef_ops} @tab 64
258 @item @code{vuse_ops} @tab 64
259 @item @code{stores} @tab 64
260 @item @code{loads} @tab 64
261 @item @code{op} @tab @code{num_ops} * 64
262 @item Total size @tab 80 + 8 * @code{num_ops} bytes
263 @end multitable
264
265 @itemize @bullet
266 @item @code{vdef_ops}
267 Similar to @code{def_ops} but for @code{VDEF} operators. There is
268 one entry per memory symbol written by this statement. This is
269 used to maintain the memory SSA use-def and def-def chains.
270
271 @item @code{vuse_ops}
272 Similar to @code{use_ops} but for @code{VUSE} operators. There is
273 one entry per memory symbol loaded by this statement. This is
274 used to maintain the memory SSA use-def chains.
275
276 @item @code{stores}
277 Bitset with all the UIDs for the symbols written-to by the
278 statement. This is different than @code{vdef_ops} in that all the
279 affected symbols are mentioned in this set. If memory
280 partitioning is enabled, the @code{vdef_ops} vector will refer to memory
281 partitions. Furthermore, no SSA information is stored in this
282 set.
283
284 @item @code{loads}
285 Similar to @code{stores}, but for memory loads. (Note that there
286 is some amount of redundancy here, it should be possible to
287 reduce memory utilization further by removing these sets).
288 @end itemize
289
290 All the other tuples are defined in terms of these three basic
291 ones. Each tuple will add some fields.
292
293
294 @node Class hierarchy of GIMPLE statements
295 @section Class hierarchy of GIMPLE statements
296 @cindex GIMPLE class hierarchy
297
298 The following diagram shows the C++ inheritance hierarchy of statement
299 kinds, along with their relationships to @code{GSS_} values (layouts) and
300 @code{GIMPLE_} values (codes):
301
302 @smallexample
303 gimple
304 | layout: GSS_BASE
305 | used for 4 codes: GIMPLE_ERROR_MARK
306 | GIMPLE_NOP
307 | GIMPLE_OMP_SECTIONS_SWITCH
308 | GIMPLE_PREDICT
309 |
310 + gimple_statement_with_ops_base
311 | | (no GSS layout)
312 | |
313 | + gimple_statement_with_ops
314 | | | layout: GSS_WITH_OPS
315 | | |
316 | | + gcond
317 | | | code: GIMPLE_COND
318 | | |
319 | | + gdebug
320 | | | code: GIMPLE_DEBUG
321 | | |
322 | | + ggoto
323 | | | code: GIMPLE_GOTO
324 | | |
325 | | + glabel
326 | | | code: GIMPLE_LABEL
327 | | |
328 | | + gswitch
329 | | code: GIMPLE_SWITCH
330 | |
331 | + gimple_statement_with_memory_ops_base
332 | | layout: GSS_WITH_MEM_OPS_BASE
333 | |
334 | + gimple_statement_with_memory_ops
335 | | | layout: GSS_WITH_MEM_OPS
336 | | |
337 | | + gassign
338 | | | code GIMPLE_ASSIGN
339 | | |
340 | | + greturn
341 | | code GIMPLE_RETURN
342 | |
343 | + gcall
344 | | layout: GSS_CALL, code: GIMPLE_CALL
345 | |
346 | + gasm
347 | | layout: GSS_ASM, code: GIMPLE_ASM
348 | |
349 | + gtransaction
350 | layout: GSS_TRANSACTION, code: GIMPLE_TRANSACTION
351 |
352 + gimple_statement_omp
353 | | layout: GSS_OMP. Used for code GIMPLE_OMP_SECTION
354 | |
355 | + gomp_critical
356 | | layout: GSS_OMP_CRITICAL, code: GIMPLE_OMP_CRITICAL
357 | |
358 | + gomp_for
359 | | layout: GSS_OMP_FOR, code: GIMPLE_OMP_FOR
360 | |
361 | + gomp_parallel_layout
362 | | | layout: GSS_OMP_PARALLEL_LAYOUT
363 | | |
364 | | + gimple_statement_omp_taskreg
365 | | | |
366 | | | + gomp_parallel
367 | | | | code: GIMPLE_OMP_PARALLEL
368 | | | |
369 | | | + gomp_task
370 | | | code: GIMPLE_OMP_TASK
371 | | |
372 | | + gimple_statement_omp_target
373 | | code: GIMPLE_OMP_TARGET
374 | |
375 | + gomp_sections
376 | | layout: GSS_OMP_SECTIONS, code: GIMPLE_OMP_SECTIONS
377 | |
378 | + gimple_statement_omp_single_layout
379 | | layout: GSS_OMP_SINGLE_LAYOUT
380 | |
381 | + gomp_single
382 | | code: GIMPLE_OMP_SINGLE
383 | |
384 | + gomp_teams
385 | code: GIMPLE_OMP_TEAMS
386 |
387 + gbind
388 | layout: GSS_BIND, code: GIMPLE_BIND
389 |
390 + gcatch
391 | layout: GSS_CATCH, code: GIMPLE_CATCH
392 |
393 + geh_filter
394 | layout: GSS_EH_FILTER, code: GIMPLE_EH_FILTER
395 |
396 + geh_else
397 | layout: GSS_EH_ELSE, code: GIMPLE_EH_ELSE
398 |
399 + geh_mnt
400 | layout: GSS_EH_MNT, code: GIMPLE_EH_MUST_NOT_THROW
401 |
402 + gphi
403 | layout: GSS_PHI, code: GIMPLE_PHI
404 |
405 + gimple_statement_eh_ctrl
406 | | layout: GSS_EH_CTRL
407 | |
408 | + gresx
409 | | code: GIMPLE_RESX
410 | |
411 | + geh_dispatch
412 | code: GIMPLE_EH_DISPATCH
413 |
414 + gtry
415 | layout: GSS_TRY, code: GIMPLE_TRY
416 |
417 + gimple_statement_wce
418 | layout: GSS_WCE, code: GIMPLE_WITH_CLEANUP_EXPR
419 |
420 + gomp_continue
421 | layout: GSS_OMP_CONTINUE, code: GIMPLE_OMP_CONTINUE
422 |
423 + gomp_atomic_load
424 | layout: GSS_OMP_ATOMIC_LOAD, code: GIMPLE_OMP_ATOMIC_LOAD
425 |
426 + gimple_statement_omp_atomic_store_layout
427 | layout: GSS_OMP_ATOMIC_STORE_LAYOUT,
428 | code: GIMPLE_OMP_ATOMIC_STORE
429 |
430 + gomp_atomic_store
431 | code: GIMPLE_OMP_ATOMIC_STORE
432 |
433 + gomp_return
434 code: GIMPLE_OMP_RETURN
435 @end smallexample
436
437
438 @node GIMPLE instruction set
439 @section GIMPLE instruction set
440 @cindex GIMPLE instruction set
441
442 The following table briefly describes the GIMPLE instruction set.
443
444 @multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE}
445 @item Instruction @tab High GIMPLE @tab Low GIMPLE
446 @item @code{GIMPLE_ASM} @tab x @tab x
447 @item @code{GIMPLE_ASSIGN} @tab x @tab x
448 @item @code{GIMPLE_BIND} @tab x @tab
449 @item @code{GIMPLE_CALL} @tab x @tab x
450 @item @code{GIMPLE_CATCH} @tab x @tab
451 @item @code{GIMPLE_COND} @tab x @tab x
452 @item @code{GIMPLE_DEBUG} @tab x @tab x
453 @item @code{GIMPLE_EH_FILTER} @tab x @tab
454 @item @code{GIMPLE_GOTO} @tab x @tab x
455 @item @code{GIMPLE_LABEL} @tab x @tab x
456 @item @code{GIMPLE_NOP} @tab x @tab x
457 @item @code{GIMPLE_OMP_ATOMIC_LOAD} @tab x @tab x
458 @item @code{GIMPLE_OMP_ATOMIC_STORE} @tab x @tab x
459 @item @code{GIMPLE_OMP_CONTINUE} @tab x @tab x
460 @item @code{GIMPLE_OMP_CRITICAL} @tab x @tab x
461 @item @code{GIMPLE_OMP_FOR} @tab x @tab x
462 @item @code{GIMPLE_OMP_MASTER} @tab x @tab x
463 @item @code{GIMPLE_OMP_ORDERED} @tab x @tab x
464 @item @code{GIMPLE_OMP_PARALLEL} @tab x @tab x
465 @item @code{GIMPLE_OMP_RETURN} @tab x @tab x
466 @item @code{GIMPLE_OMP_SECTION} @tab x @tab x
467 @item @code{GIMPLE_OMP_SECTIONS} @tab x @tab x
468 @item @code{GIMPLE_OMP_SECTIONS_SWITCH} @tab x @tab x
469 @item @code{GIMPLE_OMP_SINGLE} @tab x @tab x
470 @item @code{GIMPLE_PHI} @tab @tab x
471 @item @code{GIMPLE_OMP_STRUCTURED_BLOCK} @tab x @tab
472 @item @code{GIMPLE_RESX} @tab @tab x
473 @item @code{GIMPLE_RETURN} @tab x @tab x
474 @item @code{GIMPLE_SWITCH} @tab x @tab x
475 @item @code{GIMPLE_TRY} @tab x @tab
476 @end multitable
477
478 @node GIMPLE Exception Handling
479 @section Exception Handling
480 @cindex GIMPLE Exception Handling
481
482 Other exception handling constructs are represented using
483 @code{GIMPLE_TRY_CATCH}. @code{GIMPLE_TRY_CATCH} has two operands. The
484 first operand is a sequence of statements to execute. If executing
485 these statements does not throw an exception, then the second operand
486 is ignored. Otherwise, if an exception is thrown, then the second
487 operand of the @code{GIMPLE_TRY_CATCH} is checked. The second
488 operand may have the following forms:
489
490 @enumerate
491
492 @item A sequence of statements to execute. When an exception occurs,
493 these statements are executed, and then the exception is rethrown.
494
495 @item A sequence of @code{GIMPLE_CATCH} statements. Each
496 @code{GIMPLE_CATCH} has a list of applicable exception types and
497 handler code. If the thrown exception matches one of the caught
498 types, the associated handler code is executed. If the handler
499 code falls off the bottom, execution continues after the original
500 @code{GIMPLE_TRY_CATCH}.
501
502 @item A @code{GIMPLE_EH_FILTER} statement. This has a list of
503 permitted exception types, and code to handle a match failure. If the
504 thrown exception does not match one of the allowed types, the
505 associated match failure code is executed. If the thrown exception
506 does match, it continues unwinding the stack looking for the next
507 handler.
508
509 @end enumerate
510
511 Currently throwing an exception is not directly represented in
512 GIMPLE, since it is implemented by calling a function. At some
513 point in the future we will want to add some way to express that
514 the call will throw an exception of a known type.
515
516 Just before running the optimizers, the compiler lowers the
517 high-level EH constructs above into a set of @samp{goto}s, magic
518 labels, and EH regions. Continuing to unwind at the end of a
519 cleanup is represented with a @code{GIMPLE_RESX}.
520
521
522 @node Temporaries
523 @section Temporaries
524 @cindex Temporaries
525
526 When gimplification encounters a subexpression that is too
527 complex, it creates a new temporary variable to hold the value of
528 the subexpression, and adds a new statement to initialize it
529 before the current statement. These special temporaries are known
530 as @samp{expression temporaries}, and are allocated using
531 @code{get_formal_tmp_var}. The compiler tries to always evaluate
532 identical expressions into the same temporary, to simplify
533 elimination of redundant calculations.
534
535 We can only use expression temporaries when we know that it will
536 not be reevaluated before its value is used, and that it will not
537 be otherwise modified@footnote{These restrictions are derived
538 from those in Morgan 4.8.}. Other temporaries can be allocated
539 using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
540
541 Currently, an expression like @code{a = b + 5} is not reduced any
542 further. We tried converting it to something like
543 @smallexample
544 T1 = b + 5;
545 a = T1;
546 @end smallexample
547 but this bloated the representation for minimal benefit. However, a
548 variable which must live in memory cannot appear in an expression; its
549 value is explicitly loaded into a temporary first. Similarly, storing
550 the value of an expression to a memory variable goes through a
551 temporary.
552
553 @node Operands
554 @section Operands
555 @cindex Operands
556
557 In general, expressions in GIMPLE consist of an operation and the
558 appropriate number of simple operands; these operands must either be a
559 GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
560 variable. More complex operands are factored out into temporaries, so
561 that
562 @smallexample
563 a = b + c + d
564 @end smallexample
565 becomes
566 @smallexample
567 T1 = b + c;
568 a = T1 + d;
569 @end smallexample
570
571 The same rule holds for arguments to a @code{GIMPLE_CALL}.
572
573 The target of an assignment is usually a variable, but can also be a
574 @code{MEM_REF} or a compound lvalue as described below.
575
576 @menu
577 * Compound Expressions::
578 * Compound Lvalues::
579 * Conditional Expressions::
580 * Logical Operators::
581 @end menu
582
583 @node Compound Expressions
584 @subsection Compound Expressions
585 @cindex Compound Expressions
586
587 The left-hand side of a C comma expression is simply moved into a separate
588 statement.
589
590 @node Compound Lvalues
591 @subsection Compound Lvalues
592 @cindex Compound Lvalues
593
594 Currently compound lvalues involving array and structure field references
595 are not broken down; an expression like @code{a.b[2] = 42} is not reduced
596 any further (though complex array subscripts are). This restriction is a
597 workaround for limitations in later optimizers; if we were to convert this
598 to
599
600 @smallexample
601 T1 = &a.b;
602 T1[2] = 42;
603 @end smallexample
604
605 alias analysis would not remember that the reference to @code{T1[2]} came
606 by way of @code{a.b}, so it would think that the assignment could alias
607 another member of @code{a}; this broke @code{struct-alias-1.c}. Future
608 optimizer improvements may make this limitation unnecessary.
609
610 @node Conditional Expressions
611 @subsection Conditional Expressions
612 @cindex Conditional Expressions
613
614 A C @code{?:} expression is converted into an @code{if} statement with
615 each branch assigning to the same temporary. So,
616
617 @smallexample
618 a = b ? c : d;
619 @end smallexample
620 becomes
621 @smallexample
622 if (b == 1)
623 T1 = c;
624 else
625 T1 = d;
626 a = T1;
627 @end smallexample
628
629 The GIMPLE level if-conversion pass re-introduces @code{?:}
630 expression, if appropriate. It is used to vectorize loops with
631 conditions using vector conditional operations.
632
633 Note that in GIMPLE, @code{if} statements are represented using
634 @code{GIMPLE_COND}, as described below.
635
636 @node Logical Operators
637 @subsection Logical Operators
638 @cindex Logical Operators
639
640 Except when they appear in the condition operand of a
641 @code{GIMPLE_COND}, logical `and' and `or' operators are simplified
642 as follows: @code{a = b && c} becomes
643
644 @smallexample
645 T1 = (bool)b;
646 if (T1 == true)
647 T1 = (bool)c;
648 a = T1;
649 @end smallexample
650
651 Note that @code{T1} in this example cannot be an expression temporary,
652 because it has two different assignments.
653
654 @subsection Manipulating operands
655
656 All gimple operands are of type @code{tree}. But only certain
657 types of trees are allowed to be used as operand tuples. Basic
658 validation is controlled by the function
659 @code{get_gimple_rhs_class}, which given a tree code, returns an
660 @code{enum} with the following values of type @code{enum
661 gimple_rhs_class}
662
663 @itemize @bullet
664 @item @code{GIMPLE_INVALID_RHS}
665 The tree cannot be used as a GIMPLE operand.
666
667 @item @code{GIMPLE_TERNARY_RHS}
668 The tree is a valid GIMPLE ternary operation.
669
670 @item @code{GIMPLE_BINARY_RHS}
671 The tree is a valid GIMPLE binary operation.
672
673 @item @code{GIMPLE_UNARY_RHS}
674 The tree is a valid GIMPLE unary operation.
675
676 @item @code{GIMPLE_SINGLE_RHS}
677 The tree is a single object, that cannot be split into simpler
678 operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc).
679
680 This operand class also acts as an escape hatch for tree nodes
681 that may be flattened out into the operand vector, but would need
682 more than two slots on the RHS. For instance, a @code{COND_EXPR}
683 expression of the form @code{(a op b) ? x : y} could be flattened
684 out on the operand vector using 4 slots, but it would also
685 require additional processing to distinguish @code{c = a op b}
686 from @code{c = a op b ? x : y}. In time, these special case tree
687 expressions should be flattened into the operand vector.
688 @end itemize
689
690 For tree nodes in the categories @code{GIMPLE_TERNARY_RHS},
691 @code{GIMPLE_BINARY_RHS} and @code{GIMPLE_UNARY_RHS}, they cannot be
692 stored inside tuples directly. They first need to be flattened and
693 separated into individual components. For instance, given the GENERIC
694 expression
695
696 @smallexample
697 a = b + c
698 @end smallexample
699
700 its tree representation is:
701
702 @smallexample
703 MODIFY_EXPR <VAR_DECL <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>
704 @end smallexample
705
706 In this case, the GIMPLE form for this statement is logically
707 identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}
708 on the RHS of the assignment is not represented as a tree,
709 instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree
710 and flattened into the GIMPLE tuple as follows:
711
712 @smallexample
713 GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>
714 @end smallexample
715
716 @subsection Operand vector allocation
717
718 The operand vector is stored at the bottom of the three tuple
719 structures that accept operands. This means, that depending on
720 the code of a given statement, its operand vector will be at
721 different offsets from the base of the structure. To access
722 tuple operands use the following accessors
723
724 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
725 Returns the number of operands in statement G.
726 @end deftypefn
727
728 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
729 Returns operand @code{I} from statement @code{G}.
730 @end deftypefn
731
732 @deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
733 Returns a pointer into the operand vector for statement @code{G}. This
734 is computed using an internal table called @code{gimple_ops_offset_}[].
735 This table is indexed by the gimple code of @code{G}.
736
737 When the compiler is built, this table is filled-in using the
738 sizes of the structures used by each statement code defined in
739 gimple.def. Since the operand vector is at the bottom of the
740 structure, for a gimple code @code{C} the offset is computed as sizeof
741 (struct-of @code{C}) - sizeof (tree).
742
743 This mechanism adds one memory indirection to every access when
744 using @code{gimple_op}(), if this becomes a bottleneck, a pass can
745 choose to memoize the result from @code{gimple_ops}() and use that to
746 access the operands.
747 @end deftypefn
748
749 @subsection Operand validation
750
751 When adding a new operand to a gimple statement, the operand will
752 be validated according to what each tuple accepts in its operand
753 vector. These predicates are called by the
754 @code{gimple_@var{name}_set_...()}. Each tuple will use one of the
755 following predicates (Note, this list is not exhaustive):
756
757 @deftypefn {GIMPLE function} bool is_gimple_val (tree t)
758 Returns true if t is a "GIMPLE value", which are all the
759 non-addressable stack variables (variables for which
760 @code{is_gimple_reg} returns true) and constants (expressions for which
761 @code{is_gimple_min_invariant} returns true).
762 @end deftypefn
763
764 @deftypefn {GIMPLE function} bool is_gimple_addressable (tree t)
765 Returns true if t is a symbol or memory reference whose address
766 can be taken.
767 @end deftypefn
768
769 @deftypefn {GIMPLE function} bool is_gimple_asm_val (tree t)
770 Similar to @code{is_gimple_val} but it also accepts hard registers.
771 @end deftypefn
772
773 @deftypefn {GIMPLE function} bool is_gimple_call_addr (tree t)
774 Return true if t is a valid expression to use as the function
775 called by a @code{GIMPLE_CALL}.
776 @end deftypefn
777
778 @deftypefn {GIMPLE function} bool is_gimple_mem_ref_addr (tree t)
779 Return true if t is a valid expression to use as first operand
780 of a @code{MEM_REF} expression.
781 @end deftypefn
782
783 @deftypefn {GIMPLE function} bool is_gimple_constant (tree t)
784 Return true if t is a valid gimple constant.
785 @end deftypefn
786
787 @deftypefn {GIMPLE function} bool is_gimple_min_invariant (tree t)
788 Return true if t is a valid minimal invariant. This is different
789 from constants, in that the specific value of t may not be known
790 at compile time, but it is known that it doesn't change (e.g.,
791 the address of a function local variable).
792 @end deftypefn
793
794 @deftypefn {GIMPLE function} bool is_gimple_ip_invariant (tree t)
795 Return true if t is an interprocedural invariant. This means that t
796 is a valid invariant in all functions (e.g.@: it can be an address of a
797 global variable but not of a local one).
798 @end deftypefn
799
800 @deftypefn {GIMPLE function} bool is_gimple_ip_invariant_address (tree t)
801 Return true if t is an @code{ADDR_EXPR} that does not change once the
802 program is running (and which is valid in all functions).
803 @end deftypefn
804
805
806 @subsection Statement validation
807
808 @deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
809 Return true if the code of g is @code{GIMPLE_ASSIGN}.
810 @end deftypefn
811
812 @deftypefn {GIMPLE function} bool is_gimple_call (gimple g)
813 Return true if the code of g is @code{GIMPLE_CALL}.
814 @end deftypefn
815
816 @deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)
817 Return true if the code of g is @code{GIMPLE_DEBUG}.
818 @end deftypefn
819
820 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple g)
821 Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
822 operation.
823 @end deftypefn
824
825 @deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g)
826 Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
827 expression to a variable.
828 @end deftypefn
829
830 @deftypefn {GIMPLE function} bool is_gimple_omp (gimple g)
831 Return true if g is any of the OpenMP codes.
832 @end deftypefn
833
834 @deftypefn {GIMPLE function} bool gimple_debug_begin_stmt_p (gimple g)
835 Return true if g is a @code{GIMPLE_DEBUG} that marks the beginning of
836 a source statement.
837 @end deftypefn
838
839 @deftypefn {GIMPLE function} bool gimple_debug_inline_entry_p (gimple g)
840 Return true if g is a @code{GIMPLE_DEBUG} that marks the entry
841 point of an inlined function.
842 @end deftypefn
843
844 @deftypefn {GIMPLE function} bool gimple_debug_nonbind_marker_p (gimple g)
845 Return true if g is a @code{GIMPLE_DEBUG} that marks a program location,
846 without any variable binding.
847 @end deftypefn
848
849 @node Manipulating GIMPLE statements
850 @section Manipulating GIMPLE statements
851 @cindex Manipulating GIMPLE statements
852
853 This section documents all the functions available to handle each
854 of the GIMPLE instructions.
855
856 @subsection Common accessors
857 The following are common accessors for gimple statements.
858
859 @deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
860 Return the code for statement @code{G}.
861 @end deftypefn
862
863 @deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
864 Return the basic block to which statement @code{G} belongs to.
865 @end deftypefn
866
867 @deftypefn {GIMPLE function} tree gimple_block (gimple g)
868 Return the lexical scope block holding statement @code{G}.
869 @end deftypefn
870
871 @deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
872 Return the tree code for the expression computed by @code{STMT}. This
873 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
874 @code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
875 For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
876 For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
877 by the @code{RHS} of the assignment.
878 @end deftypefn
879
880 @deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
881 Set the lexical scope block of @code{G} to @code{BLOCK}.
882 @end deftypefn
883
884 @deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
885 Return locus information for statement @code{G}.
886 @end deftypefn
887
888 @deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
889 Set locus information for statement @code{G}.
890 @end deftypefn
891
892 @deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
893 Return true if @code{G} does not have locus information.
894 @end deftypefn
895
896 @deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
897 Return true if no warnings should be emitted for statement @code{STMT}.
898 @end deftypefn
899
900 @deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
901 Set the visited status on statement @code{STMT} to @code{VISITED_P}.
902 @end deftypefn
903
904 @deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
905 Return the visited status on statement @code{STMT}.
906 @end deftypefn
907
908 @deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
909 Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
910 @end deftypefn
911
912 @deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
913 Return the value of pass local flag @code{PLF} on statement @code{STMT}.
914 @end deftypefn
915
916 @deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
917 Return true if statement @code{G} has register or memory operands.
918 @end deftypefn
919
920 @deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
921 Return true if statement @code{G} has memory operands.
922 @end deftypefn
923
924 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
925 Return the number of operands for statement @code{G}.
926 @end deftypefn
927
928 @deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
929 Return the array of operands for statement @code{G}.
930 @end deftypefn
931
932 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
933 Return operand @code{I} for statement @code{G}.
934 @end deftypefn
935
936 @deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
937 Return a pointer to operand @code{I} for statement @code{G}.
938 @end deftypefn
939
940 @deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
941 Set operand @code{I} of statement @code{G} to @code{OP}.
942 @end deftypefn
943
944 @deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
945 Return the set of symbols that have had their address taken by
946 @code{STMT}.
947 @end deftypefn
948
949 @deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
950 Return the set of @code{DEF} operands for statement @code{G}.
951 @end deftypefn
952
953 @deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
954 Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
955 @end deftypefn
956
957 @deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
958 Return the set of @code{USE} operands for statement @code{G}.
959 @end deftypefn
960
961 @deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
962 Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
963 @end deftypefn
964
965 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
966 Return the set of @code{VUSE} operands for statement @code{G}.
967 @end deftypefn
968
969 @deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
970 Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
971 @end deftypefn
972
973 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
974 Return the set of @code{VDEF} operands for statement @code{G}.
975 @end deftypefn
976
977 @deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
978 Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
979 @end deftypefn
980
981 @deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
982 Return the set of symbols loaded by statement @code{G}. Each element of
983 the set is the @code{DECL_UID} of the corresponding symbol.
984 @end deftypefn
985
986 @deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
987 Return the set of symbols stored by statement @code{G}. Each element of
988 the set is the @code{DECL_UID} of the corresponding symbol.
989 @end deftypefn
990
991 @deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
992 Return true if statement @code{G} has operands and the modified field
993 has been set.
994 @end deftypefn
995
996 @deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
997 Return true if statement @code{STMT} contains volatile operands.
998 @end deftypefn
999
1000 @deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
1001 Return true if statement @code{STMT} contains volatile operands.
1002 @end deftypefn
1003
1004 @deftypefn {GIMPLE function} void update_stmt (gimple s)
1005 Mark statement @code{S} as modified, and update it.
1006 @end deftypefn
1007
1008 @deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
1009 Update statement @code{S} if it has been marked modified.
1010 @end deftypefn
1011
1012 @deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
1013 Return a deep copy of statement @code{STMT}.
1014 @end deftypefn
1015
1016 @node Tuple specific accessors
1017 @section Tuple specific accessors
1018 @cindex Tuple specific accessors
1019
1020 @menu
1021 * @code{GIMPLE_ASM}::
1022 * @code{GIMPLE_ASSIGN}::
1023 * @code{GIMPLE_BIND}::
1024 * @code{GIMPLE_CALL}::
1025 * @code{GIMPLE_CATCH}::
1026 * @code{GIMPLE_COND}::
1027 * @code{GIMPLE_DEBUG}::
1028 * @code{GIMPLE_EH_FILTER}::
1029 * @code{GIMPLE_LABEL}::
1030 * @code{GIMPLE_GOTO}::
1031 * @code{GIMPLE_NOP}::
1032 * @code{GIMPLE_OMP_ATOMIC_LOAD}::
1033 * @code{GIMPLE_OMP_ATOMIC_STORE}::
1034 * @code{GIMPLE_OMP_CONTINUE}::
1035 * @code{GIMPLE_OMP_CRITICAL}::
1036 * @code{GIMPLE_OMP_FOR}::
1037 * @code{GIMPLE_OMP_MASTER}::
1038 * @code{GIMPLE_OMP_ORDERED}::
1039 * @code{GIMPLE_OMP_PARALLEL}::
1040 * @code{GIMPLE_OMP_RETURN}::
1041 * @code{GIMPLE_OMP_SECTION}::
1042 * @code{GIMPLE_OMP_SECTIONS}::
1043 * @code{GIMPLE_OMP_SINGLE}::
1044 * @code{GIMPLE_OMP_STRUCTURED_BLOCK}::
1045 * @code{GIMPLE_PHI}::
1046 * @code{GIMPLE_RESX}::
1047 * @code{GIMPLE_RETURN}::
1048 * @code{GIMPLE_SWITCH}::
1049 * @code{GIMPLE_TRY}::
1050 * @code{GIMPLE_WITH_CLEANUP_EXPR}::
1051 @end menu
1052
1053
1054 @node @code{GIMPLE_ASM}
1055 @subsection @code{GIMPLE_ASM}
1056 @cindex @code{GIMPLE_ASM}
1057
1058 @deftypefn {GIMPLE function} gasm *gimple_build_asm_vec ( @
1059 const char *string, vec<tree, va_gc> *inputs, @
1060 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers, @
1061 vec<tree, va_gc> *labels)
1062 Build a @code{GIMPLE_ASM} statement. This statement is used for
1063 building in-line assembly constructs. @code{STRING} is the assembly
1064 code. @code{INPUTS}, @code{OUTPUTS}, @code{CLOBBERS} and @code{LABELS}
1065 are the inputs, outputs, clobbered registers and labels.
1066 @end deftypefn
1067
1068 @deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (const gasm *g)
1069 Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
1070 @end deftypefn
1071
1072 @deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (const gasm *g)
1073 Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
1074 @end deftypefn
1075
1076 @deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (const gasm *g)
1077 Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
1078 @end deftypefn
1079
1080 @deftypefn {GIMPLE function} tree gimple_asm_input_op (const gasm *g, @
1081 unsigned index)
1082 Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1083 @end deftypefn
1084
1085 @deftypefn {GIMPLE function} void gimple_asm_set_input_op (gasm *g, @
1086 unsigned index, tree in_op)
1087 Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1088 @end deftypefn
1089
1090 @deftypefn {GIMPLE function} tree gimple_asm_output_op (const gasm *g, @
1091 unsigned index)
1092 Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1093 @end deftypefn
1094
1095 @deftypefn {GIMPLE function} void gimple_asm_set_output_op (gasm *g, @
1096 unsigned index, tree out_op)
1097 Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1098 @end deftypefn
1099
1100 @deftypefn {GIMPLE function} tree gimple_asm_clobber_op (const gasm *g, @
1101 unsigned index)
1102 Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1103 @end deftypefn
1104
1105 @deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gasm *g, @
1106 unsigned index, tree clobber_op)
1107 Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1108 @end deftypefn
1109
1110 @deftypefn {GIMPLE function} {const char *} gimple_asm_string (const gasm *g)
1111 Return the string representing the assembly instruction in
1112 @code{GIMPLE_ASM} @code{G}.
1113 @end deftypefn
1114
1115 @deftypefn {GIMPLE function} bool gimple_asm_basic_p (const gasm *g)
1116 Return true if @code{G} is a basic asm rather than an extended asm.
1117 @end deftypefn
1118
1119 @deftypefn {GIMPLE function} void gimple_asm_set_basic (gasm *g, bool basic_p)
1120 Mark asm statement @code{G} as a basic asm or an extended asm based on
1121 @code{BASIC_P}.
1122 @end deftypefn
1123
1124 @deftypefn {GIMPLE function} bool gimple_asm_volatile_p (const gasm *g)
1125 Return true if @code{G} is an asm statement marked volatile.
1126 @end deftypefn
1127
1128 @deftypefn {GIMPLE function} void gimple_asm_set_volatile (gasm *g, @
1129 bool volatile_p)
1130 Mark asm statement @code{G} as volatile or non-volatile based on
1131 @code{VOLATILE_P}.
1132 @end deftypefn
1133
1134 @node @code{GIMPLE_ASSIGN}
1135 @subsection @code{GIMPLE_ASSIGN}
1136 @cindex @code{GIMPLE_ASSIGN}
1137
1138 @deftypefn {GIMPLE function} gassign *gimple_build_assign (tree lhs, tree rhs)
1139 Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue
1140 passed in lhs. The right-hand side can be either a unary or
1141 binary tree expression. The expression tree rhs will be
1142 flattened and its operands assigned to the corresponding operand
1143 slots in the new statement. This function is useful when you
1144 already have a tree expression that you want to convert into a
1145 tuple. However, try to avoid building expression trees for the
1146 sole purpose of calling this function. If you already have the
1147 operands in separate trees, it is better to use
1148 @code{gimple_build_assign} with @code{enum tree_code} argument and separate
1149 arguments for each operand.
1150 @end deftypefn
1151
1152 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1153 (tree lhs, enum tree_code subcode, tree op1, tree op2, tree op3)
1154 This function is similar to two operand @code{gimple_build_assign},
1155 but is used to build a @code{GIMPLE_ASSIGN} statement when the operands of the
1156 right-hand side of the assignment are already split into
1157 different operands.
1158
1159 The left-hand side is an lvalue passed in lhs. Subcode is the
1160 @code{tree_code} for the right-hand side of the assignment. Op1, op2 and op3
1161 are the operands.
1162 @end deftypefn
1163
1164 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1165 (tree lhs, enum tree_code subcode, tree op1, tree op2)
1166 Like the above 5 operand @code{gimple_build_assign}, but with the last
1167 argument @code{NULL} - this overload should not be used for
1168 @code{GIMPLE_TERNARY_RHS} assignments.
1169 @end deftypefn
1170
1171 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1172 (tree lhs, enum tree_code subcode, tree op1)
1173 Like the above 4 operand @code{gimple_build_assign}, but with the last
1174 argument @code{NULL} - this overload should be used only for
1175 @code{GIMPLE_UNARY_RHS} and @code{GIMPLE_SINGLE_RHS} assignments.
1176 @end deftypefn
1177
1178 @deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
1179 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
1180 @code{*SEQ_P}.
1181 @end deftypefn
1182
1183 @code{DST}/@code{SRC} are the destination and source respectively. You can
1184 pass ungimplified trees in @code{DST} or @code{SRC}, in which
1185 case they will be converted to a gimple operand if necessary.
1186
1187 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
1188
1189 @deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
1190 Return the code of the expression computed on the @code{RHS} of
1191 assignment statement @code{G}.
1192 @end deftypefn
1193
1194
1195 @deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
1196 Return the gimple rhs class of the code for the expression
1197 computed on the rhs of assignment statement @code{G}. This will never
1198 return @code{GIMPLE_INVALID_RHS}.
1199 @end deftypefn
1200
1201 @deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
1202 Return the @code{LHS} of assignment statement @code{G}.
1203 @end deftypefn
1204
1205 @deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
1206 Return a pointer to the @code{LHS} of assignment statement @code{G}.
1207 @end deftypefn
1208
1209 @deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
1210 Return the first operand on the @code{RHS} of assignment statement @code{G}.
1211 @end deftypefn
1212
1213 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
1214 Return the address of the first operand on the @code{RHS} of assignment
1215 statement @code{G}.
1216 @end deftypefn
1217
1218 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
1219 Return the second operand on the @code{RHS} of assignment statement @code{G}.
1220 @end deftypefn
1221
1222 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
1223 Return the address of the second operand on the @code{RHS} of assignment
1224 statement @code{G}.
1225 @end deftypefn
1226
1227 @deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
1228 Return the third operand on the @code{RHS} of assignment statement @code{G}.
1229 @end deftypefn
1230
1231 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
1232 Return the address of the third operand on the @code{RHS} of assignment
1233 statement @code{G}.
1234 @end deftypefn
1235
1236 @deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
1237 Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
1238 @end deftypefn
1239
1240 @deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
1241 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
1242 statement @code{G}.
1243 @end deftypefn
1244
1245 @deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
1246 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
1247 statement @code{G}.
1248 @end deftypefn
1249
1250 @deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
1251 Set @code{RHS} to be the third operand on the @code{RHS} of assignment
1252 statement @code{G}.
1253 @end deftypefn
1254
1255 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple s)
1256 Return true if @code{S} is a type-cast assignment.
1257 @end deftypefn
1258
1259
1260 @node @code{GIMPLE_BIND}
1261 @subsection @code{GIMPLE_BIND}
1262 @cindex @code{GIMPLE_BIND}
1263
1264 @deftypefn {GIMPLE function} gbind *gimple_build_bind (tree vars, @
1265 gimple_seq body)
1266 Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
1267 and a body of statements in sequence @code{BODY}.
1268 @end deftypefn
1269
1270 @deftypefn {GIMPLE function} tree gimple_bind_vars (const gbind *g)
1271 Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
1272 @end deftypefn
1273
1274 @deftypefn {GIMPLE function} void gimple_bind_set_vars (gbind *g, tree vars)
1275 Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
1276 statement @code{G}.
1277 @end deftypefn
1278
1279 @deftypefn {GIMPLE function} void gimple_bind_append_vars (gbind *g, tree vars)
1280 Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
1281 statement @code{G}.
1282 @end deftypefn
1283
1284 @deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gbind *g)
1285 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
1286 @code{G}.
1287 @end deftypefn
1288
1289 @deftypefn {GIMPLE function} void gimple_bind_set_body (gbind *g, @
1290 gimple_seq seq)
1291 Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
1292 @end deftypefn
1293
1294 @deftypefn {GIMPLE function} void gimple_bind_add_stmt (gbind *gs, gimple stmt)
1295 Append a statement to the end of a @code{GIMPLE_BIND}'s body.
1296 @end deftypefn
1297
1298 @deftypefn {GIMPLE function} void gimple_bind_add_seq (gbind *gs, @
1299 gimple_seq seq)
1300 Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
1301 body.
1302 @end deftypefn
1303
1304 @deftypefn {GIMPLE function} tree gimple_bind_block (const gbind *g)
1305 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
1306 @code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
1307 @end deftypefn
1308
1309 @deftypefn {GIMPLE function} void gimple_bind_set_block (gbind *g, tree block)
1310 Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
1311 statement @code{G}.
1312 @end deftypefn
1313
1314
1315 @node @code{GIMPLE_CALL}
1316 @subsection @code{GIMPLE_CALL}
1317 @cindex @code{GIMPLE_CALL}
1318
1319 @deftypefn {GIMPLE function} gcall *gimple_build_call (tree fn, @
1320 unsigned nargs, ...)
1321 Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN}
1322 must be either a @code{FUNCTION_DECL} or a gimple call address as
1323 determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of
1324 arguments. The rest of the arguments follow the argument @code{NARGS},
1325 and must be trees that are valid as rvalues in gimple (i.e., each
1326 operand is validated with @code{is_gimple_operand}).
1327 @end deftypefn
1328
1329
1330 @deftypefn {GIMPLE function} gcall *gimple_build_call_from_tree (tree call_expr, @
1331 tree fnptrtype)
1332 Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments
1333 and the function are taken from the expression directly. The type of the
1334 @code{GIMPLE_CALL} is set from the second parameter passed by a caller.
1335 This routine assumes that @code{call_expr} is already in GIMPLE form.
1336 That is, its operands are GIMPLE values and the function call needs no further
1337 simplification. All the call flags in @code{call_expr} are copied over
1338 to the new @code{GIMPLE_CALL}.
1339 @end deftypefn
1340
1341 @deftypefn {GIMPLE function} gcall *gimple_build_call_vec (tree fn, @
1342 @code{vec<tree>} args)
1343 Identical to @code{gimple_build_call} but the arguments are stored in a
1344 @code{vec<tree>}.
1345 @end deftypefn
1346
1347 @deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
1348 Return the @code{LHS} of call statement @code{G}.
1349 @end deftypefn
1350
1351 @deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
1352 Return a pointer to the @code{LHS} of call statement @code{G}.
1353 @end deftypefn
1354
1355 @deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
1356 Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
1357 @end deftypefn
1358
1359 @deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
1360 Return the tree node representing the function called by call
1361 statement @code{G}.
1362 @end deftypefn
1363
1364 @deftypefn {GIMPLE function} void gimple_call_set_fn (gcall *g, tree fn)
1365 Set @code{FN} to be the function called by call statement @code{G}. This has
1366 to be a gimple value specifying the address of the called
1367 function.
1368 @end deftypefn
1369
1370 @deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
1371 If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
1372 Otherwise return @code{NULL}. This function is analogous to
1373 @code{get_callee_fndecl} in @code{GENERIC}.
1374 @end deftypefn
1375
1376 @deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
1377 Set the called function to @code{FNDECL}.
1378 @end deftypefn
1379
1380 @deftypefn {GIMPLE function} tree gimple_call_return_type (const gcall *g)
1381 Return the type returned by call statement @code{G}.
1382 @end deftypefn
1383
1384 @deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
1385 Return the static chain for call statement @code{G}.
1386 @end deftypefn
1387
1388 @deftypefn {GIMPLE function} void gimple_call_set_chain (gcall *g, tree chain)
1389 Set @code{CHAIN} to be the static chain for call statement @code{G}.
1390 @end deftypefn
1391
1392 @deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
1393 Return the number of arguments used by call statement @code{G}.
1394 @end deftypefn
1395
1396 @deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
1397 Return the argument at position @code{INDEX} for call statement @code{G}. The
1398 first argument is 0.
1399 @end deftypefn
1400
1401 @deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
1402 Return a pointer to the argument at position @code{INDEX} for call
1403 statement @code{G}.
1404 @end deftypefn
1405
1406 @deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
1407 Set @code{ARG} to be the argument at position @code{INDEX} for call statement
1408 @code{G}.
1409 @end deftypefn
1410
1411 @deftypefn {GIMPLE function} void gimple_call_set_tail (gcall *s)
1412 Mark call statement @code{S} as being a tail call (i.e., a call just
1413 before the exit of a function). These calls are candidate for
1414 tail call optimization.
1415 @end deftypefn
1416
1417 @deftypefn {GIMPLE function} bool gimple_call_tail_p (gcall *s)
1418 Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
1419 @end deftypefn
1420
1421 @deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
1422 Return true if @code{S} is a noreturn call.
1423 @end deftypefn
1424
1425 @deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gcall *stmt, @
1426 bitmap args_to_skip)
1427 Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
1428 in the positions marked by the set @code{ARGS_TO_SKIP}.
1429 @end deftypefn
1430
1431
1432 @node @code{GIMPLE_CATCH}
1433 @subsection @code{GIMPLE_CATCH}
1434 @cindex @code{GIMPLE_CATCH}
1435
1436 @deftypefn {GIMPLE function} gcatch *gimple_build_catch (tree types, @
1437 gimple_seq handler)
1438 Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this
1439 catch handles. @code{HANDLER} is a sequence of statements with the code
1440 for the handler.
1441 @end deftypefn
1442
1443 @deftypefn {GIMPLE function} tree gimple_catch_types (const gcatch *g)
1444 Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
1445 @end deftypefn
1446
1447 @deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gcatch *g)
1448 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
1449 @code{G}.
1450 @end deftypefn
1451
1452 @deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gcatch *g)
1453 Return the GIMPLE sequence representing the body of the handler
1454 of @code{GIMPLE_CATCH} statement @code{G}.
1455 @end deftypefn
1456
1457 @deftypefn {GIMPLE function} void gimple_catch_set_types (gcatch *g, tree t)
1458 Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
1459 @end deftypefn
1460
1461 @deftypefn {GIMPLE function} void gimple_catch_set_handler (gcatch *g, @
1462 gimple_seq handler)
1463 Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
1464 @end deftypefn
1465
1466
1467 @node @code{GIMPLE_COND}
1468 @subsection @code{GIMPLE_COND}
1469 @cindex @code{GIMPLE_COND}
1470
1471 @deftypefn {GIMPLE function} gcond *gimple_build_cond ( @
1472 enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
1473 Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares
1474 @code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
1475 the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
1476 @code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
1477 @code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
1478 @end deftypefn
1479
1480
1481 @deftypefn {GIMPLE function} gcond *gimple_build_cond_from_tree (tree cond, @
1482 tree t_label, tree f_label)
1483 Build a @code{GIMPLE_COND} statement from the conditional expression
1484 tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
1485 @end deftypefn
1486
1487 @deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
1488 Return the code of the predicate computed by conditional
1489 statement @code{G}.
1490 @end deftypefn
1491
1492 @deftypefn {GIMPLE function} void gimple_cond_set_code (gcond *g, @
1493 enum tree_code code)
1494 Set @code{CODE} to be the predicate code for the conditional statement
1495 @code{G}.
1496 @end deftypefn
1497
1498 @deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
1499 Return the @code{LHS} of the predicate computed by conditional statement
1500 @code{G}.
1501 @end deftypefn
1502
1503 @deftypefn {GIMPLE function} void gimple_cond_set_lhs (gcond *g, tree lhs)
1504 Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
1505 conditional statement @code{G}.
1506 @end deftypefn
1507
1508 @deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
1509 Return the @code{RHS} operand of the predicate computed by conditional
1510 @code{G}.
1511 @end deftypefn
1512
1513 @deftypefn {GIMPLE function} void gimple_cond_set_rhs (gcond *g, tree rhs)
1514 Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
1515 conditional statement @code{G}.
1516 @end deftypefn
1517
1518 @deftypefn {GIMPLE function} tree gimple_cond_true_label (const gcond *g)
1519 Return the label used by conditional statement @code{G} when its
1520 predicate evaluates to true.
1521 @end deftypefn
1522
1523 @deftypefn {GIMPLE function} void gimple_cond_set_true_label (gcond *g, tree label)
1524 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1525 its predicate evaluates to true.
1526 @end deftypefn
1527
1528 @deftypefn {GIMPLE function} void gimple_cond_set_false_label (gcond *g, tree label)
1529 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1530 its predicate evaluates to false.
1531 @end deftypefn
1532
1533 @deftypefn {GIMPLE function} tree gimple_cond_false_label (const gcond *g)
1534 Return the label used by conditional statement @code{G} when its
1535 predicate evaluates to false.
1536 @end deftypefn
1537
1538 @deftypefn {GIMPLE function} void gimple_cond_make_false (gcond *g)
1539 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
1540 @end deftypefn
1541
1542 @deftypefn {GIMPLE function} void gimple_cond_make_true (gcond *g)
1543 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
1544 @end deftypefn
1545
1546 @node @code{GIMPLE_DEBUG}
1547 @subsection @code{GIMPLE_DEBUG}
1548 @cindex @code{GIMPLE_DEBUG}
1549 @cindex @code{GIMPLE_DEBUG_BIND}
1550 @cindex @code{GIMPLE_DEBUG_BEGIN_STMT}
1551 @cindex @code{GIMPLE_DEBUG_INLINE_ENTRY}
1552
1553 @deftypefn {GIMPLE function} gdebug *gimple_build_debug_bind (tree var, @
1554 tree value, gimple stmt)
1555 Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND}
1556 @code{subcode}. The effect of this statement is to tell debug
1557 information generation machinery that the value of user variable
1558 @code{var} is given by @code{value} at that point, and to remain with
1559 that value until @code{var} runs out of scope, a
1560 dynamically-subsequent debug bind statement overrides the binding, or
1561 conflicting values reach a control flow merge point. Even if
1562 components of the @code{value} expression change afterwards, the
1563 variable is supposed to retain the same value, though not necessarily
1564 the same location.
1565
1566 It is expected that @code{var} be most often a tree for automatic user
1567 variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the
1568 requirements for gimple registers, but it may also be a tree for a
1569 scalarized component of a user variable (@code{ARRAY_REF},
1570 @code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}).
1571
1572 As for @code{value}, it can be an arbitrary tree expression, but it is
1573 recommended that it be in a suitable form for a gimple assignment
1574 @code{RHS}. It is not expected that user variables that could appear
1575 as @code{var} ever appear in @code{value}, because in the latter we'd
1576 have their @code{SSA_NAME}s instead, but even if they were not in SSA
1577 form, user variables appearing in @code{value} are to be regarded as
1578 part of the executable code space, whereas those in @code{var} are to
1579 be regarded as part of the source code space. There is no way to
1580 refer to the value bound to a user variable within a @code{value}
1581 expression.
1582
1583 If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
1584 generation machinery is informed that the variable @code{var} is
1585 unbound, i.e., that its value is indeterminate, which sometimes means
1586 it is really unavailable, and other times that the compiler could not
1587 keep track of it.
1588
1589 Block and location information for the newly-created stmt are
1590 taken from @code{stmt}, if given.
1591 @end deftypefn
1592
1593 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
1594 Return the user variable @var{var} that is bound at @code{stmt}.
1595 @end deftypefn
1596
1597 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
1598 Return the value expression that is bound to a user variable at
1599 @code{stmt}.
1600 @end deftypefn
1601
1602 @deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt)
1603 Return a pointer to the value expression that is bound to a user
1604 variable at @code{stmt}.
1605 @end deftypefn
1606
1607 @deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
1608 Modify the user variable bound at @code{stmt} to @var{var}.
1609 @end deftypefn
1610
1611 @deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
1612 Modify the value bound to the user variable bound at @code{stmt} to
1613 @var{value}.
1614 @end deftypefn
1615
1616 @deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
1617 Modify the value bound to the user variable bound at @code{stmt} so
1618 that the variable becomes unbound.
1619 @end deftypefn
1620
1621 @deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
1622 Return @code{TRUE} if @code{stmt} binds a user variable to a value,
1623 and @code{FALSE} if it unbinds the variable.
1624 @end deftypefn
1625
1626 @deftypefn {GIMPLE function} gimple gimple_build_debug_begin_stmt (tree block, location_t location)
1627 Build a @code{GIMPLE_DEBUG} statement with
1628 @code{GIMPLE_DEBUG_BEGIN_STMT} @code{subcode}. The effect of this
1629 statement is to tell debug information generation machinery that the
1630 user statement at the given @code{location} and @code{block} starts at
1631 the point at which the statement is inserted. The intent is that side
1632 effects (e.g.@: variable bindings) of all prior user statements are
1633 observable, and that none of the side effects of subsequent user
1634 statements are.
1635 @end deftypefn
1636
1637 @deftypefn {GIMPLE function} gimple gimple_build_debug_inline_entry (tree block, location_t location)
1638 Build a @code{GIMPLE_DEBUG} statement with
1639 @code{GIMPLE_DEBUG_INLINE_ENTRY} @code{subcode}. The effect of this
1640 statement is to tell debug information generation machinery that a
1641 function call at @code{location} underwent inline substitution, that
1642 @code{block} is the enclosing lexical block created for the
1643 substitution, and that at the point of the program in which the stmt is
1644 inserted, all parameters for the inlined function are bound to the
1645 respective arguments, and none of the side effects of its stmts are
1646 observable.
1647 @end deftypefn
1648
1649 @node @code{GIMPLE_EH_FILTER}
1650 @subsection @code{GIMPLE_EH_FILTER}
1651 @cindex @code{GIMPLE_EH_FILTER}
1652
1653 @deftypefn {GIMPLE function} geh_filter *gimple_build_eh_filter (tree types, @
1654 gimple_seq failure)
1655 Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's
1656 types. @code{FAILURE} is a sequence with the filter's failure action.
1657 @end deftypefn
1658
1659 @deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
1660 Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
1661 @end deftypefn
1662
1663 @deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
1664 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
1665 statement @code{G}.
1666 @end deftypefn
1667
1668 @deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
1669 Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
1670 statement fails.
1671 @end deftypefn
1672
1673 @deftypefn {GIMPLE function} void gimple_eh_filter_set_types (geh_filter *g, @
1674 tree types)
1675 Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
1676 @end deftypefn
1677
1678 @deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (geh_filter *g, @
1679 gimple_seq failure)
1680 Set @code{FAILURE} to be the sequence of statements to execute on
1681 failure for @code{GIMPLE_EH_FILTER} @code{G}.
1682 @end deftypefn
1683
1684 @deftypefn {GIMPLE function} tree gimple_eh_must_not_throw_fndecl ( @
1685 geh_mnt *eh_mnt_stmt)
1686 Get the function decl to be called by the MUST_NOT_THROW region.
1687 @end deftypefn
1688
1689 @deftypefn {GIMPLE function} void gimple_eh_must_not_throw_set_fndecl ( @
1690 geh_mnt *eh_mnt_stmt, tree decl)
1691 Set the function decl to be called by GS to DECL.
1692 @end deftypefn
1693
1694
1695 @node @code{GIMPLE_LABEL}
1696 @subsection @code{GIMPLE_LABEL}
1697 @cindex @code{GIMPLE_LABEL}
1698
1699 @deftypefn {GIMPLE function} glabel *gimple_build_label (tree label)
1700 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
1701 label, @code{LABEL}.
1702 @end deftypefn
1703
1704 @deftypefn {GIMPLE function} tree gimple_label_label (const glabel *g)
1705 Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
1706 @end deftypefn
1707
1708 @deftypefn {GIMPLE function} void gimple_label_set_label (glabel *g, tree label)
1709 Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
1710 statement @code{G}.
1711 @end deftypefn
1712
1713 @node @code{GIMPLE_GOTO}
1714 @subsection @code{GIMPLE_GOTO}
1715 @cindex @code{GIMPLE_GOTO}
1716
1717 @deftypefn {GIMPLE function} ggoto *gimple_build_goto (tree dest)
1718 Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
1719 @end deftypefn
1720
1721 @deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
1722 Return the destination of the unconditional jump @code{G}.
1723 @end deftypefn
1724
1725 @deftypefn {GIMPLE function} void gimple_goto_set_dest (ggoto *g, tree dest)
1726 Set @code{DEST} to be the destination of the unconditional jump @code{G}.
1727 @end deftypefn
1728
1729
1730 @node @code{GIMPLE_NOP}
1731 @subsection @code{GIMPLE_NOP}
1732 @cindex @code{GIMPLE_NOP}
1733
1734 @deftypefn {GIMPLE function} gimple gimple_build_nop (void)
1735 Build a @code{GIMPLE_NOP} statement.
1736 @end deftypefn
1737
1738 @deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
1739 Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
1740 @end deftypefn
1741
1742 @node @code{GIMPLE_OMP_ATOMIC_LOAD}
1743 @subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
1744 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
1745
1746 @deftypefn {GIMPLE function} gomp_atomic_load *gimple_build_omp_atomic_load ( @
1747 tree lhs, tree rhs)
1748 Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand
1749 side of the assignment. @code{RHS} is the right-hand side of the
1750 assignment.
1751 @end deftypefn
1752
1753 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs ( @
1754 gomp_atomic_load *g, tree lhs)
1755 Set the @code{LHS} of an atomic load.
1756 @end deftypefn
1757
1758 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs ( @
1759 const gomp_atomic_load *g)
1760 Get the @code{LHS} of an atomic load.
1761 @end deftypefn
1762
1763 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs ( @
1764 gomp_atomic_load *g, tree rhs)
1765 Set the @code{RHS} of an atomic set.
1766 @end deftypefn
1767
1768 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs ( @
1769 const gomp_atomic_load *g)
1770 Get the @code{RHS} of an atomic set.
1771 @end deftypefn
1772
1773
1774 @node @code{GIMPLE_OMP_ATOMIC_STORE}
1775 @subsection @code{GIMPLE_OMP_ATOMIC_STORE}
1776 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
1777
1778 @deftypefn {GIMPLE function} gomp_atomic_store *gimple_build_omp_atomic_store ( @
1779 tree val)
1780 Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
1781 stored.
1782 @end deftypefn
1783
1784 @deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val ( @
1785 gomp_atomic_store *g, tree val)
1786 Set the value being stored in an atomic store.
1787 @end deftypefn
1788
1789 @deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val ( @
1790 const gomp_atomic_store *g)
1791 Return the value being stored in an atomic store.
1792 @end deftypefn
1793
1794 @node @code{GIMPLE_OMP_CONTINUE}
1795 @subsection @code{GIMPLE_OMP_CONTINUE}
1796 @cindex @code{GIMPLE_OMP_CONTINUE}
1797
1798 @deftypefn {GIMPLE function} gomp_continue *gimple_build_omp_continue ( @
1799 tree control_def, tree control_use)
1800 Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the
1801 definition of the control variable. @code{CONTROL_USE} is the use of
1802 the control variable.
1803 @end deftypefn
1804
1805 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def ( @
1806 const gomp_continue *s)
1807 Return the definition of the control variable on a
1808 @code{GIMPLE_OMP_CONTINUE} in @code{S}.
1809 @end deftypefn
1810
1811 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr ( @
1812 gomp_continue *s)
1813 Same as above, but return the pointer.
1814 @end deftypefn
1815
1816 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def ( @
1817 gomp_continue *s)
1818 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
1819 statement in @code{S}.
1820 @end deftypefn
1821
1822 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use ( @
1823 const gomp_continue *s)
1824 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
1825 in @code{S}.
1826 @end deftypefn
1827
1828 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr ( @
1829 gomp_continue *s)
1830 Same as above, but return the pointer.
1831 @end deftypefn
1832
1833 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use ( @
1834 gomp_continue *s)
1835 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
1836 in @code{S}.
1837 @end deftypefn
1838
1839
1840 @node @code{GIMPLE_OMP_CRITICAL}
1841 @subsection @code{GIMPLE_OMP_CRITICAL}
1842 @cindex @code{GIMPLE_OMP_CRITICAL}
1843
1844 @deftypefn {GIMPLE function} gomp_critical *gimple_build_omp_critical ( @
1845 gimple_seq body, tree name)
1846 Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
1847 statements for which only one thread can execute. @code{NAME} is an
1848 optional identifier for this critical block.
1849 @end deftypefn
1850
1851 @deftypefn {GIMPLE function} tree gimple_omp_critical_name ( @
1852 const gomp_critical *g)
1853 Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
1854 @end deftypefn
1855
1856 @deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr ( @
1857 gomp_critical *g)
1858 Return a pointer to the name associated with @code{OMP} critical
1859 statement @code{G}.
1860 @end deftypefn
1861
1862 @deftypefn {GIMPLE function} void gimple_omp_critical_set_name ( @
1863 gomp_critical *g, tree name)
1864 Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
1865 @end deftypefn
1866
1867 @node @code{GIMPLE_OMP_FOR}
1868 @subsection @code{GIMPLE_OMP_FOR}
1869 @cindex @code{GIMPLE_OMP_FOR}
1870
1871 @deftypefn {GIMPLE function} gomp_for *gimple_build_omp_for (gimple_seq body, @
1872 tree clauses, tree index, tree initial, tree final, tree incr, @
1873 gimple_seq pre_body, enum tree_code omp_for_cond)
1874 Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
1875 inside the for loop. @code{CLAUSES}, are any of the loop
1876 construct's clauses. @code{PRE_BODY} is the
1877 sequence of statements that are loop invariant. @code{INDEX} is the
1878 index variable. @code{INITIAL} is the initial value of @code{INDEX}. @code{FINAL} is
1879 final value of @code{INDEX}. OMP_FOR_COND is the predicate used to
1880 compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression.
1881 @end deftypefn
1882
1883 @deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
1884 Return the clauses associated with @code{OMP_FOR} @code{G}.
1885 @end deftypefn
1886
1887 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
1888 Return a pointer to the @code{OMP_FOR} @code{G}.
1889 @end deftypefn
1890
1891 @deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
1892 Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
1893 @end deftypefn
1894
1895 @deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
1896 Return the index variable for @code{OMP_FOR} @code{G}.
1897 @end deftypefn
1898
1899 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
1900 Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
1901 @end deftypefn
1902
1903 @deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
1904 Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
1905 @end deftypefn
1906
1907 @deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
1908 Return the initial value for @code{OMP_FOR} @code{G}.
1909 @end deftypefn
1910
1911 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
1912 Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
1913 @end deftypefn
1914
1915 @deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
1916 Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
1917 @end deftypefn
1918
1919 @deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
1920 Return the final value for @code{OMP_FOR} @code{G}.
1921 @end deftypefn
1922
1923 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
1924 turn a pointer to the final value for @code{OMP_FOR} @code{G}.
1925 @end deftypefn
1926
1927 @deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
1928 Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
1929 @end deftypefn
1930
1931 @deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
1932 Return the increment value for @code{OMP_FOR} @code{G}.
1933 @end deftypefn
1934
1935 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
1936 Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
1937 @end deftypefn
1938
1939 @deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
1940 Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
1941 @end deftypefn
1942
1943 @deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
1944 Return the sequence of statements to execute before the @code{OMP_FOR}
1945 statement @code{G} starts.
1946 @end deftypefn
1947
1948 @deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
1949 Set @code{PRE_BODY} to be the sequence of statements to execute before
1950 the @code{OMP_FOR} statement @code{G} starts.
1951 @end deftypefn
1952
1953 @deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
1954 Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
1955 @end deftypefn
1956
1957 @deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
1958 Return the condition code associated with @code{OMP_FOR} @code{G}.
1959 @end deftypefn
1960
1961
1962 @node @code{GIMPLE_OMP_MASTER}
1963 @subsection @code{GIMPLE_OMP_MASTER}
1964 @cindex @code{GIMPLE_OMP_MASTER}
1965
1966 @deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
1967 Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
1968 statements to be executed by just the master.
1969 @end deftypefn
1970
1971
1972 @node @code{GIMPLE_OMP_ORDERED}
1973 @subsection @code{GIMPLE_OMP_ORDERED}
1974 @cindex @code{GIMPLE_OMP_ORDERED}
1975
1976 @deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
1977 Build a @code{GIMPLE_OMP_ORDERED} statement.
1978
1979 @code{BODY} is the sequence of statements inside a loop that will
1980 executed in sequence.
1981 @end deftypefn
1982
1983 @node @code{GIMPLE_OMP_PARALLEL}
1984 @subsection @code{GIMPLE_OMP_PARALLEL}
1985 @cindex @code{GIMPLE_OMP_PARALLEL}
1986
1987 @deftypefn {GIMPLE function} gomp_parallel *gimple_build_omp_parallel (@
1988 gimple_seq body, tree clauses, tree child_fn, tree data_arg)
1989 Build a @code{GIMPLE_OMP_PARALLEL} statement.
1990
1991 @code{BODY} is sequence of statements which are executed in parallel.
1992 @code{CLAUSES}, are the @code{OMP} parallel construct's clauses. @code{CHILD_FN} is
1993 the function created for the parallel threads to execute.
1994 @code{DATA_ARG} are the shared data argument(s).
1995 @end deftypefn
1996
1997 @deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
1998 Return true if @code{OMP} parallel statement @code{G} has the
1999 @code{GF_OMP_PARALLEL_COMBINED} flag set.
2000 @end deftypefn
2001
2002 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
2003 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
2004 @code{G}.
2005 @end deftypefn
2006
2007 @deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
2008 Return the body for the @code{OMP} statement @code{G}.
2009 @end deftypefn
2010
2011 @deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
2012 Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
2013 @end deftypefn
2014
2015 @deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
2016 Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
2017 @end deftypefn
2018
2019 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr ( @
2020 gomp_parallel *g)
2021 Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
2022 @end deftypefn
2023
2024 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses ( @
2025 gomp_parallel *g, tree clauses)
2026 Set @code{CLAUSES} to be the list of clauses associated with
2027 @code{OMP_PARALLEL} @code{G}.
2028 @end deftypefn
2029
2030 @deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn ( @
2031 const gomp_parallel *g)
2032 Return the child function used to hold the body of @code{OMP_PARALLEL}
2033 @code{G}.
2034 @end deftypefn
2035
2036 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr ( @
2037 gomp_parallel *g)
2038 Return a pointer to the child function used to hold the body of
2039 @code{OMP_PARALLEL} @code{G}.
2040 @end deftypefn
2041
2042 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn ( @
2043 gomp_parallel *g, tree child_fn)
2044 Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
2045 @end deftypefn
2046
2047 @deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg ( @
2048 const gomp_parallel *g)
2049 Return the artificial argument used to send variables and values
2050 from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
2051 @end deftypefn
2052
2053 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr ( @
2054 gomp_parallel *g)
2055 Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
2056 @end deftypefn
2057
2058 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg ( @
2059 gomp_parallel *g, tree data_arg)
2060 Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
2061 @end deftypefn
2062
2063
2064 @node @code{GIMPLE_OMP_RETURN}
2065 @subsection @code{GIMPLE_OMP_RETURN}
2066 @cindex @code{GIMPLE_OMP_RETURN}
2067
2068 @deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
2069 Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
2070 non-waiting return.
2071 @end deftypefn
2072
2073 @deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
2074 Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
2075 @end deftypefn
2076
2077
2078 @deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
2079 Return true if @code{OMP} return statement @code{G} has the
2080 @code{GF_OMP_RETURN_NOWAIT} flag set.
2081 @end deftypefn
2082
2083 @node @code{GIMPLE_OMP_SECTION}
2084 @subsection @code{GIMPLE_OMP_SECTION}
2085 @cindex @code{GIMPLE_OMP_SECTION}
2086
2087 @deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
2088 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
2089
2090 @code{BODY} is the sequence of statements in the section.
2091 @end deftypefn
2092
2093 @deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
2094 Return true if @code{OMP} section statement @code{G} has the
2095 @code{GF_OMP_SECTION_LAST} flag set.
2096 @end deftypefn
2097
2098 @deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
2099 Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
2100 @end deftypefn
2101
2102 @node @code{GIMPLE_OMP_SECTIONS}
2103 @subsection @code{GIMPLE_OMP_SECTIONS}
2104 @cindex @code{GIMPLE_OMP_SECTIONS}
2105
2106 @deftypefn {GIMPLE function} gomp_sections *gimple_build_omp_sections ( @
2107 gimple_seq body, tree clauses)
2108 Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
2109 section statements. @code{CLAUSES} are any of the @code{OMP} sections
2110 construct's clauses: private, firstprivate, lastprivate,
2111 reduction, and nowait.
2112 @end deftypefn
2113
2114
2115 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
2116 Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
2117 @end deftypefn
2118
2119 @deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
2120 Return the control variable associated with the
2121 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2122 @end deftypefn
2123
2124 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
2125 Return a pointer to the clauses associated with the
2126 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2127 @end deftypefn
2128
2129 @deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
2130 Set @code{CONTROL} to be the set of clauses associated with the
2131 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2132 @end deftypefn
2133
2134 @deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
2135 Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
2136 @end deftypefn
2137
2138 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
2139 Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
2140 @end deftypefn
2141
2142 @deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
2143 Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
2144 @code{G}.
2145 @end deftypefn
2146
2147
2148 @node @code{GIMPLE_OMP_SINGLE}
2149 @subsection @code{GIMPLE_OMP_SINGLE}
2150 @cindex @code{GIMPLE_OMP_SINGLE}
2151
2152 @deftypefn {GIMPLE function} gomp_single *gimple_build_omp_single ( @
2153 gimple_seq body, tree clauses)
2154 Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
2155 statements that will be executed once. @code{CLAUSES} are any of the
2156 @code{OMP} single construct's clauses: private, firstprivate,
2157 copyprivate, nowait.
2158 @end deftypefn
2159
2160 @deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
2161 Return the clauses associated with @code{OMP_SINGLE} @code{G}.
2162 @end deftypefn
2163
2164 @deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
2165 Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
2166 @end deftypefn
2167
2168 @deftypefn {GIMPLE function} void gimple_omp_single_set_clauses ( @
2169 gomp_single *g, tree clauses)
2170 Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
2171 @end deftypefn
2172
2173
2174 @node @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2175 @subsection @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2176 @cindex @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2177
2178 Like the GENERIC equivalent @code{OMP_STRUCTURED_BLOCK}, this GIMPLE
2179 statement does not correspond directly to an OpenMP directive, and
2180 exists only to permit error checking of transfers of control
2181 in/out of structured block sequences (the @code{diagnose_omp_blocks} pass
2182 in @file{omp-low.cc}). All @code{GIMPLE_OMP_STRUCTURED_BLOCK}
2183 nodes are eliminated during OpenMP lowering.
2184
2185 @deftypefn {GIMPLE function} gimple gimple_build_omp_structured_block (gimple_seq body)
2186 Build a @code{GIMPLE_OMP_STRUCTURED_BLOCK} statement.
2187 @code{BODY} is the sequence of statements in the structured block sequence.
2188 @end deftypefn
2189
2190
2191 @node @code{GIMPLE_PHI}
2192 @subsection @code{GIMPLE_PHI}
2193 @cindex @code{GIMPLE_PHI}
2194
2195 @deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
2196 Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
2197 @end deftypefn
2198
2199 @deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
2200 Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
2201 be exactly the number of incoming edges for the basic block
2202 holding @code{G}.
2203 @end deftypefn
2204
2205 @deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
2206 Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2207 @end deftypefn
2208
2209 @deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
2210 Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2211 @end deftypefn
2212
2213 @deftypefn {GIMPLE function} void gimple_phi_set_result (gphi *g, tree result)
2214 Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2215 @end deftypefn
2216
2217 @deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
2218 Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
2219 @code{GIMPLE_PHI} @code{G}.
2220 @end deftypefn
2221
2222 @deftypefn {GIMPLE function} void gimple_phi_set_arg (gphi *g, index, @
2223 struct phi_arg_d * phiarg)
2224 Set @code{PHIARG} to be the argument corresponding to incoming edge
2225 @code{INDEX} for @code{GIMPLE_PHI} @code{G}.
2226 @end deftypefn
2227
2228 @node @code{GIMPLE_RESX}
2229 @subsection @code{GIMPLE_RESX}
2230 @cindex @code{GIMPLE_RESX}
2231
2232 @deftypefn {GIMPLE function} gresx *gimple_build_resx (int region)
2233 Build a @code{GIMPLE_RESX} statement which is a statement. This
2234 statement is a placeholder for _Unwind_Resume before we know if a
2235 function call or a branch is needed. @code{REGION} is the exception
2236 region from which control is flowing.
2237 @end deftypefn
2238
2239 @deftypefn {GIMPLE function} int gimple_resx_region (const gresx *g)
2240 Return the region number for @code{GIMPLE_RESX} @code{G}.
2241 @end deftypefn
2242
2243 @deftypefn {GIMPLE function} void gimple_resx_set_region (gresx *g, int region)
2244 Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
2245 @end deftypefn
2246
2247 @node @code{GIMPLE_RETURN}
2248 @subsection @code{GIMPLE_RETURN}
2249 @cindex @code{GIMPLE_RETURN}
2250
2251 @deftypefn {GIMPLE function} greturn *gimple_build_return (tree retval)
2252 Build a @code{GIMPLE_RETURN} statement whose return value is retval.
2253 @end deftypefn
2254
2255 @deftypefn {GIMPLE function} tree gimple_return_retval (const greturn *g)
2256 Return the return value for @code{GIMPLE_RETURN} @code{G}.
2257 @end deftypefn
2258
2259 @deftypefn {GIMPLE function} void gimple_return_set_retval (greturn *g, @
2260 tree retval)
2261 Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
2262 @end deftypefn
2263
2264 @node @code{GIMPLE_SWITCH}
2265 @subsection @code{GIMPLE_SWITCH}
2266 @cindex @code{GIMPLE_SWITCH}
2267
2268 @deftypefn {GIMPLE function} gswitch *gimple_build_switch (tree index, @
2269 tree default_label, @code{vec}<tree> *args)
2270 Build a @code{GIMPLE_SWITCH} statement. @code{INDEX} is the index variable
2271 to switch on, and @code{DEFAULT_LABEL} represents the default label.
2272 @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
2273 non-default case labels. Each label is a tree of code @code{CASE_LABEL_EXPR}.
2274 @end deftypefn
2275
2276 @deftypefn {GIMPLE function} unsigned gimple_switch_num_labels ( @
2277 const gswitch *g)
2278 Return the number of labels associated with the switch statement
2279 @code{G}.
2280 @end deftypefn
2281
2282 @deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gswitch *g, @
2283 unsigned nlabels)
2284 Set @code{NLABELS} to be the number of labels for the switch statement
2285 @code{G}.
2286 @end deftypefn
2287
2288 @deftypefn {GIMPLE function} tree gimple_switch_index (const gswitch *g)
2289 Return the index variable used by the switch statement @code{G}.
2290 @end deftypefn
2291
2292 @deftypefn {GIMPLE function} void gimple_switch_set_index (gswitch *g, @
2293 tree index)
2294 Set @code{INDEX} to be the index variable for switch statement @code{G}.
2295 @end deftypefn
2296
2297 @deftypefn {GIMPLE function} tree gimple_switch_label (const gswitch *g, @
2298 unsigned index)
2299 Return the label numbered @code{INDEX}. The default label is 0, followed
2300 by any labels in a switch statement.
2301 @end deftypefn
2302
2303 @deftypefn {GIMPLE function} void gimple_switch_set_label (gswitch *g, @
2304 unsigned index, tree label)
2305 Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
2306 label.
2307 @end deftypefn
2308
2309 @deftypefn {GIMPLE function} tree gimple_switch_default_label ( @
2310 const gswitch *g)
2311 Return the default label for a switch statement.
2312 @end deftypefn
2313
2314 @deftypefn {GIMPLE function} void gimple_switch_set_default_label (gswitch *g, @
2315 tree label)
2316 Set the default label for a switch statement.
2317 @end deftypefn
2318
2319
2320 @node @code{GIMPLE_TRY}
2321 @subsection @code{GIMPLE_TRY}
2322 @cindex @code{GIMPLE_TRY}
2323
2324 @deftypefn {GIMPLE function} gtry *gimple_build_try (gimple_seq eval, @
2325 gimple_seq cleanup, unsigned int kind)
2326 Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the
2327 expression to evaluate. @code{CLEANUP} is a sequence of statements to
2328 run at clean-up time. @code{KIND} is the enumeration value
2329 @code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
2330 or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
2331 construct.
2332 @end deftypefn
2333
2334 @deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
2335 Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
2336 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
2337 @end deftypefn
2338
2339 @deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
2340 Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2341 @end deftypefn
2342
2343 @deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
2344 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
2345 @code{G}.
2346 @end deftypefn
2347
2348 @deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
2349 Return the sequence of statements used as the cleanup body for
2350 @code{GIMPLE_TRY} @code{G}.
2351 @end deftypefn
2352
2353 @deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
2354 bool catch_is_cleanup)
2355 Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2356 @end deftypefn
2357
2358 @deftypefn {GIMPLE function} void gimple_try_set_eval (gtry *g, gimple_seq eval)
2359 Set @code{EVAL} to be the sequence of statements to use as the body for
2360 @code{GIMPLE_TRY} @code{G}.
2361 @end deftypefn
2362
2363 @deftypefn {GIMPLE function} void gimple_try_set_cleanup (gtry *g, @
2364 gimple_seq cleanup)
2365 Set @code{CLEANUP} to be the sequence of statements to use as the
2366 cleanup body for @code{GIMPLE_TRY} @code{G}.
2367 @end deftypefn
2368
2369 @node @code{GIMPLE_WITH_CLEANUP_EXPR}
2370 @subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
2371 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
2372
2373 @deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
2374 Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement. @code{CLEANUP} is the
2375 clean-up expression.
2376 @end deftypefn
2377
2378 @deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
2379 Return the cleanup sequence for cleanup statement @code{G}.
2380 @end deftypefn
2381
2382 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
2383 Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
2384 @end deftypefn
2385
2386 @deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
2387 Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2388 @end deftypefn
2389
2390 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
2391 Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2392 @end deftypefn
2393
2394
2395 @node GIMPLE sequences
2396 @section GIMPLE sequences
2397 @cindex GIMPLE sequences
2398
2399 GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
2400 used in @code{GENERIC}. They are used to chain statements together, and
2401 when used in conjunction with sequence iterators, provide a
2402 framework for iterating through statements.
2403
2404 GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
2405 commonly passed by reference to functions dealing with sequences.
2406 The type for a sequence pointer is @code{gimple_seq} which is the same
2407 as struct @code{gimple_sequence} *. When declaring a local sequence,
2408 you can define a local variable of type struct @code{gimple_sequence}.
2409 When declaring a sequence allocated on the garbage collected
2410 heap, use the function @code{gimple_seq_alloc} documented below.
2411
2412 There are convenience functions for iterating through sequences
2413 in the section entitled Sequence Iterators.
2414
2415 Below is a list of functions to manipulate and query sequences.
2416
2417 @deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
2418 Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
2419 not @code{NULL}. If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
2420 @end deftypefn
2421
2422 @deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
2423 Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
2424 @code{NULL}. If *@code{DEST} is @code{NULL}, allocate a new sequence before
2425 appending.
2426 @end deftypefn
2427
2428 @deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
2429 Perform a deep copy of sequence @code{SRC} and return the result.
2430 @end deftypefn
2431
2432 @deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
2433 Reverse the order of the statements in the sequence @code{SEQ}. Return
2434 @code{SEQ}.
2435 @end deftypefn
2436
2437 @deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
2438 Return the first statement in sequence @code{S}.
2439 @end deftypefn
2440
2441 @deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
2442 Return the last statement in sequence @code{S}.
2443 @end deftypefn
2444
2445 @deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
2446 Set the last statement in sequence @code{S} to the statement in @code{LAST}.
2447 @end deftypefn
2448
2449 @deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
2450 Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
2451 @end deftypefn
2452
2453 @deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
2454 Initialize sequence @code{S} to an empty sequence.
2455 @end deftypefn
2456
2457 @deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
2458 Allocate a new sequence in the garbage collected store and return
2459 it.
2460 @end deftypefn
2461
2462 @deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
2463 Copy the sequence @code{SRC} into the sequence @code{DEST}.
2464 @end deftypefn
2465
2466 @deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
2467 Return true if the sequence @code{S} is empty.
2468 @end deftypefn
2469
2470 @deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
2471 Returns the sequence of statements in @code{BB}.
2472 @end deftypefn
2473
2474 @deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
2475 Sets the sequence of statements in @code{BB} to @code{SEQ}.
2476 @end deftypefn
2477
2478 @deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
2479 Determine whether @code{SEQ} contains exactly one statement.
2480 @end deftypefn
2481
2482 @node Sequence iterators
2483 @section Sequence iterators
2484 @cindex Sequence iterators
2485
2486 Sequence iterators are convenience constructs for iterating
2487 through statements in a sequence. Given a sequence @code{SEQ}, here is
2488 a typical use of gimple sequence iterators:
2489
2490 @smallexample
2491 gimple_stmt_iterator gsi;
2492
2493 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
2494 @{
2495 gimple g = gsi_stmt (gsi);
2496 /* Do something with gimple statement @code{G}. */
2497 @}
2498 @end smallexample
2499
2500 Backward iterations are possible:
2501
2502 @smallexample
2503 for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
2504 @end smallexample
2505
2506 Forward and backward iterations on basic blocks are possible with
2507 @code{gsi_start_bb} and @code{gsi_last_bb}.
2508
2509 In the documentation below we sometimes refer to enum
2510 @code{gsi_iterator_update}. The valid options for this enumeration are:
2511
2512 @itemize @bullet
2513 @item @code{GSI_NEW_STMT}
2514 Only valid when a single statement is added. Move the iterator to it.
2515
2516 @item @code{GSI_SAME_STMT}
2517 Leave the iterator at the same statement.
2518
2519 @item @code{GSI_CONTINUE_LINKING}
2520 Move iterator to whatever position is suitable for linking other
2521 statements in the same direction.
2522 @end itemize
2523
2524 Below is a list of the functions used to manipulate and use
2525 statement iterators.
2526
2527 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
2528 Return a new iterator pointing to the sequence @code{SEQ}'s first
2529 statement. If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
2530 Use @code{gsi_start_bb} instead when the iterator needs to always have
2531 the correct basic block set.
2532 @end deftypefn
2533
2534 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
2535 Return a new iterator pointing to the first statement in basic
2536 block @code{BB}.
2537 @end deftypefn
2538
2539 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
2540 Return a new iterator initially pointing to the last statement of
2541 sequence @code{SEQ}. If @code{SEQ} is empty, the iterator's basic block is
2542 @code{NULL}. Use @code{gsi_last_bb} instead when the iterator needs to always
2543 have the correct basic block set.
2544 @end deftypefn
2545
2546 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
2547 Return a new iterator pointing to the last statement in basic
2548 block @code{BB}.
2549 @end deftypefn
2550
2551 @deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
2552 Return @code{TRUE} if at the end of @code{I}.
2553 @end deftypefn
2554
2555 @deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
2556 Return @code{TRUE} if we're one statement before the end of @code{I}.
2557 @end deftypefn
2558
2559 @deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
2560 Advance the iterator to the next gimple statement.
2561 @end deftypefn
2562
2563 @deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
2564 Advance the iterator to the previous gimple statement.
2565 @end deftypefn
2566
2567 @deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
2568 Return the current stmt.
2569 @end deftypefn
2570
2571 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb)
2572 Return a block statement iterator that points to the first
2573 non-label statement in block @code{BB}.
2574 @end deftypefn
2575
2576 @deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i)
2577 Return a pointer to the current stmt.
2578 @end deftypefn
2579
2580 @deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
2581 Return the basic block associated with this iterator.
2582 @end deftypefn
2583
2584 @deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
2585 Return the sequence associated with this iterator.
2586 @end deftypefn
2587
2588 @deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
2589 Remove the current stmt from the sequence. The iterator is
2590 updated to point to the next statement. When @code{REMOVE_EH_INFO} is
2591 true we remove the statement pointed to by iterator @code{I} from the @code{EH}
2592 tables. Otherwise we do not modify the @code{EH} tables. Generally,
2593 @code{REMOVE_EH_INFO} should be true when the statement is going to be
2594 removed from the @code{IL} and not reinserted elsewhere.
2595 @end deftypefn
2596
2597 @deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2598 Links the sequence of statements @code{SEQ} before the statement pointed
2599 by iterator @code{I}. @code{MODE} indicates what to do with the iterator
2600 after insertion (see @code{enum gsi_iterator_update} above).
2601 @end deftypefn
2602
2603 @deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
2604 Links statement @code{G} before the statement pointed-to by iterator @code{I}.
2605 Updates iterator @code{I} according to @code{MODE}.
2606 @end deftypefn
2607
2608 @deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, @
2609 gimple_seq seq, enum gsi_iterator_update mode)
2610 Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
2611 @code{MODE} is as in @code{gsi_insert_after}.
2612 @end deftypefn
2613
2614 @deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
2615 gimple g, enum gsi_iterator_update mode)
2616 Links statement @code{G} after the statement pointed-to by iterator @code{I}.
2617 @code{MODE} is as in @code{gsi_insert_after}.
2618 @end deftypefn
2619
2620 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
2621 Move all statements in the sequence after @code{I} to a new sequence.
2622 Return this new sequence.
2623 @end deftypefn
2624
2625 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
2626 Move all statements in the sequence before @code{I} to a new sequence.
2627 Return this new sequence.
2628 @end deftypefn
2629
2630 @deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @
2631 gimple stmt, bool update_eh_info)
2632 Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO}
2633 is true, the exception handling information of the original
2634 statement is moved to the new statement.
2635 @end deftypefn
2636
2637 @deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
2638 gimple stmt, enum gsi_iterator_update mode)
2639 Insert statement @code{STMT} before the statement pointed-to by iterator
2640 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2641 specifies how to update iterator @code{I} after insertion (see enum
2642 @code{gsi_iterator_update}).
2643 @end deftypefn
2644
2645 @deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, @
2646 gimple_seq seq, enum gsi_iterator_update mode)
2647 Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
2648 @end deftypefn
2649
2650 @deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
2651 gimple stmt, enum gsi_iterator_update mode)
2652 Insert statement @code{STMT} after the statement pointed-to by iterator
2653 @code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
2654 specifies how to update iterator @code{I} after insertion (see enum
2655 @code{gsi_iterator_update}).
2656 @end deftypefn
2657
2658 @deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, @
2659 gimple_seq seq, enum gsi_iterator_update mode)
2660 Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
2661 @end deftypefn
2662
2663 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
2664 Finds iterator for @code{STMT}.
2665 @end deftypefn
2666
2667 @deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, @
2668 gimple_stmt_iterator *to)
2669 Move the statement at @code{FROM} so it comes right after the statement
2670 at @code{TO}.
2671 @end deftypefn
2672
2673 @deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, @
2674 gimple_stmt_iterator *to)
2675 Move the statement at @code{FROM} so it comes right before the statement
2676 at @code{TO}.
2677 @end deftypefn
2678
2679 @deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, @
2680 basic_block bb)
2681 Move the statement at @code{FROM} to the end of basic block @code{BB}.
2682 @end deftypefn
2683
2684 @deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
2685 Add @code{STMT} to the pending list of edge @code{E}. No actual insertion is
2686 made until a call to @code{gsi_commit_edge_inserts}() is made.
2687 @end deftypefn
2688
2689 @deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
2690 Add the sequence of statements in @code{SEQ} to the pending list of edge
2691 @code{E}. No actual insertion is made until a call to
2692 @code{gsi_commit_edge_inserts}() is made.
2693 @end deftypefn
2694
2695 @deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
2696 Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}. If a new
2697 block has to be created, it is returned.
2698 @end deftypefn
2699
2700 @deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
2701 Commit insertions pending at edge @code{E}. If a new block is created,
2702 set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
2703 @end deftypefn
2704
2705 @deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
2706 This routine will commit all pending edge insertions, creating
2707 any new basic blocks which are necessary.
2708 @end deftypefn
2709
2710
2711 @node Adding a new GIMPLE statement code
2712 @section Adding a new GIMPLE statement code
2713 @cindex Adding a new GIMPLE statement code
2714
2715 The first step in adding a new GIMPLE statement code, is
2716 modifying the file @code{gimple.def}, which contains all the GIMPLE
2717 codes. Then you must add a corresponding gimple subclass
2718 located in @code{gimple.h}. This in turn, will require you to add a
2719 corresponding @code{GTY} tag in @code{gsstruct.def}, and code to handle
2720 this tag in @code{gss_for_code} which is located in @code{gimple.cc}.
2721
2722 In order for the garbage collector to know the size of the
2723 structure you created in @code{gimple.h}, you need to add a case to
2724 handle your new GIMPLE statement in @code{gimple_size} which is located
2725 in @code{gimple.cc}.
2726
2727 You will probably want to create a function to build the new
2728 gimple statement in @code{gimple.cc}. The function should be called
2729 @code{gimple_build_@var{new-tuple-name}}, and should return the new tuple
2730 as a pointer to the appropriate gimple subclass.
2731
2732 If your new statement requires accessors for any members or
2733 operands it may have, put simple inline accessors in
2734 @code{gimple.h} and any non-trivial accessors in @code{gimple.cc} with a
2735 corresponding prototype in @code{gimple.h}.
2736
2737 You should add the new statement subclass to the class hierarchy diagram
2738 in @code{gimple.texi}.
2739
2740
2741 @node Statement and operand traversals
2742 @section Statement and operand traversals
2743 @cindex Statement and operand traversals
2744
2745 There are two functions available for walking statements and
2746 sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
2747 accordingly, and a third function for walking the operands in a
2748 statement: @code{walk_gimple_op}.
2749
2750 @deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, @
2751 walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2752 This function is used to walk the current statement in @code{GSI},
2753 optionally using traversal state stored in @code{WI}. If @code{WI} is @code{NULL}, no
2754 state is kept during the traversal.
2755
2756 The callback @code{CALLBACK_STMT} is called. If @code{CALLBACK_STMT} returns
2757 true, it means that the callback function has handled all the
2758 operands of the statement and it is not necessary to walk its
2759 operands.
2760
2761 If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
2762 called on each operand of the statement via @code{walk_gimple_op}. If
2763 @code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
2764 operands are not scanned.
2765
2766 The return value is that returned by the last call to
2767 @code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
2768 @end deftypefn
2769
2770
2771 @deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @
2772 walk_tree_fn callback_op, struct walk_stmt_info *wi)
2773 Use this function to walk the operands of statement @code{STMT}. Every
2774 operand is walked via @code{walk_tree} with optional state information
2775 in @code{WI}.
2776
2777 @code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
2778 Additional parameters to @code{walk_tree} must be stored in @code{WI}. For
2779 each operand @code{OP}, @code{walk_tree} is called as:
2780
2781 @smallexample
2782 walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{PSET})
2783 @end smallexample
2784
2785 If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
2786 operands are not scanned. The return value is that returned by
2787 the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
2788 specified.
2789 @end deftypefn
2790
2791
2792 @deftypefn {GIMPLE function} tree walk_gimple_seq (gimple_seq seq, @
2793 walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2794 This function walks all the statements in the sequence @code{SEQ}
2795 calling @code{walk_gimple_stmt} on each one. @code{WI} is as in
2796 @code{walk_gimple_stmt}. If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
2797 is stopped and the value returned. Otherwise, all the statements
2798 are walked and @code{NULL_TREE} returned.
2799 @end deftypefn