Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / doc / gimple.texi
1 @c Copyright (C) 2008-2015 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_statement_base} (gsbase)
96 @cindex gimple_statement_base
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_statement_base}.
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_statement_base
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_RESX}                @tab                    @tab x
472 @item @code{GIMPLE_RETURN}              @tab x                  @tab x
473 @item @code{GIMPLE_SWITCH}              @tab x                  @tab x
474 @item @code{GIMPLE_TRY}                 @tab x                  @tab
475 @end multitable
476
477 @node GIMPLE Exception Handling
478 @section Exception Handling
479 @cindex GIMPLE Exception Handling
480
481 Other exception handling constructs are represented using
482 @code{GIMPLE_TRY_CATCH}.  @code{GIMPLE_TRY_CATCH} has two operands.  The
483 first operand is a sequence of statements to execute.  If executing
484 these statements does not throw an exception, then the second operand
485 is ignored.  Otherwise, if an exception is thrown, then the second
486 operand of the @code{GIMPLE_TRY_CATCH} is checked.  The second
487 operand may have the following forms:
488
489 @enumerate
490
491 @item A sequence of statements to execute.  When an exception occurs,
492 these statements are executed, and then the exception is rethrown.
493
494 @item A sequence of @code{GIMPLE_CATCH} statements.  Each
495 @code{GIMPLE_CATCH} has a list of applicable exception types and
496 handler code.  If the thrown exception matches one of the caught
497 types, the associated handler code is executed.  If the handler
498 code falls off the bottom, execution continues after the original
499 @code{GIMPLE_TRY_CATCH}.
500
501 @item A @code{GIMPLE_EH_FILTER} statement.  This has a list of
502 permitted exception types, and code to handle a match failure.  If the
503 thrown exception does not match one of the allowed types, the
504 associated match failure code is executed.  If the thrown exception
505 does match, it continues unwinding the stack looking for the next
506 handler.
507
508 @end enumerate
509
510 Currently throwing an exception is not directly represented in
511 GIMPLE, since it is implemented by calling a function.  At some
512 point in the future we will want to add some way to express that
513 the call will throw an exception of a known type.
514
515 Just before running the optimizers, the compiler lowers the
516 high-level EH constructs above into a set of @samp{goto}s, magic
517 labels, and EH regions.  Continuing to unwind at the end of a
518 cleanup is represented with a @code{GIMPLE_RESX}.
519
520
521 @node Temporaries
522 @section Temporaries
523 @cindex Temporaries
524
525 When gimplification encounters a subexpression that is too
526 complex, it creates a new temporary variable to hold the value of
527 the subexpression, and adds a new statement to initialize it
528 before the current statement. These special temporaries are known
529 as @samp{expression temporaries}, and are allocated using
530 @code{get_formal_tmp_var}.  The compiler tries to always evaluate
531 identical expressions into the same temporary, to simplify
532 elimination of redundant calculations.
533
534 We can only use expression temporaries when we know that it will
535 not be reevaluated before its value is used, and that it will not
536 be otherwise modified@footnote{These restrictions are derived
537 from those in Morgan 4.8.}. Other temporaries can be allocated
538 using @code{get_initialized_tmp_var} or @code{create_tmp_var}.
539
540 Currently, an expression like @code{a = b + 5} is not reduced any
541 further.  We tried converting it to something like
542 @smallexample
543 T1 = b + 5;
544 a = T1;
545 @end smallexample
546 but this bloated the representation for minimal benefit.  However, a
547 variable which must live in memory cannot appear in an expression; its
548 value is explicitly loaded into a temporary first.  Similarly, storing
549 the value of an expression to a memory variable goes through a
550 temporary.
551
552 @node Operands
553 @section Operands
554 @cindex Operands
555
556 In general, expressions in GIMPLE consist of an operation and the
557 appropriate number of simple operands; these operands must either be a
558 GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register
559 variable.  More complex operands are factored out into temporaries, so
560 that
561 @smallexample
562 a = b + c + d
563 @end smallexample
564 becomes
565 @smallexample
566 T1 = b + c;
567 a = T1 + d;
568 @end smallexample
569
570 The same rule holds for arguments to a @code{GIMPLE_CALL}.
571
572 The target of an assignment is usually a variable, but can also be a
573 @code{MEM_REF} or a compound lvalue as described below.
574
575 @menu
576 * Compound Expressions::
577 * Compound Lvalues::
578 * Conditional Expressions::
579 * Logical Operators::
580 @end menu
581
582 @node Compound Expressions
583 @subsection Compound Expressions
584 @cindex Compound Expressions
585
586 The left-hand side of a C comma expression is simply moved into a separate
587 statement.
588
589 @node Compound Lvalues
590 @subsection Compound Lvalues
591 @cindex Compound Lvalues
592
593 Currently compound lvalues involving array and structure field references
594 are not broken down; an expression like @code{a.b[2] = 42} is not reduced
595 any further (though complex array subscripts are).  This restriction is a
596 workaround for limitations in later optimizers; if we were to convert this
597 to
598
599 @smallexample
600 T1 = &a.b;
601 T1[2] = 42;
602 @end smallexample
603
604 alias analysis would not remember that the reference to @code{T1[2]} came
605 by way of @code{a.b}, so it would think that the assignment could alias
606 another member of @code{a}; this broke @code{struct-alias-1.c}.  Future
607 optimizer improvements may make this limitation unnecessary.
608
609 @node Conditional Expressions
610 @subsection Conditional Expressions
611 @cindex Conditional Expressions
612
613 A C @code{?:} expression is converted into an @code{if} statement with
614 each branch assigning to the same temporary.  So,
615
616 @smallexample
617 a = b ? c : d;
618 @end smallexample
619 becomes
620 @smallexample
621 if (b == 1)
622   T1 = c;
623 else
624   T1 = d;
625 a = T1;
626 @end smallexample
627
628 The GIMPLE level if-conversion pass re-introduces @code{?:}
629 expression, if appropriate. It is used to vectorize loops with
630 conditions using vector conditional operations.
631
632 Note that in GIMPLE, @code{if} statements are represented using
633 @code{GIMPLE_COND}, as described below.
634
635 @node Logical Operators
636 @subsection Logical Operators
637 @cindex Logical Operators
638
639 Except when they appear in the condition operand of a
640 @code{GIMPLE_COND}, logical `and' and `or' operators are simplified
641 as follows: @code{a = b && c} becomes
642
643 @smallexample
644 T1 = (bool)b;
645 if (T1 == true)
646   T1 = (bool)c;
647 a = T1;
648 @end smallexample
649
650 Note that @code{T1} in this example cannot be an expression temporary,
651 because it has two different assignments.
652
653 @subsection Manipulating operands
654
655 All gimple operands are of type @code{tree}.  But only certain
656 types of trees are allowed to be used as operand tuples.  Basic
657 validation is controlled by the function
658 @code{get_gimple_rhs_class}, which given a tree code, returns an
659 @code{enum} with the following values of type @code{enum
660 gimple_rhs_class}
661
662 @itemize @bullet
663 @item @code{GIMPLE_INVALID_RHS}
664 The tree cannot be used as a GIMPLE operand.
665
666 @item @code{GIMPLE_TERNARY_RHS}
667 The tree is a valid GIMPLE ternary operation.
668
669 @item @code{GIMPLE_BINARY_RHS}
670 The tree is a valid GIMPLE binary operation.
671
672 @item @code{GIMPLE_UNARY_RHS}
673 The tree is a valid GIMPLE unary operation.
674
675 @item @code{GIMPLE_SINGLE_RHS}
676 The tree is a single object, that cannot be split into simpler
677 operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc).
678
679 This operand class also acts as an escape hatch for tree nodes
680 that may be flattened out into the operand vector, but would need
681 more than two slots on the RHS.  For instance, a @code{COND_EXPR}
682 expression of the form @code{(a op b) ? x : y} could be flattened
683 out on the operand vector using 4 slots, but it would also
684 require additional processing to distinguish @code{c = a op b}
685 from @code{c = a op b ? x : y}.  Something similar occurs with
686 @code{ASSERT_EXPR}.   In time, these special case tree
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 @node Manipulating GIMPLE statements
835 @section Manipulating GIMPLE statements
836 @cindex Manipulating GIMPLE statements
837
838 This section documents all the functions available to handle each
839 of the GIMPLE instructions.
840
841 @subsection Common accessors
842 The following are common accessors for gimple statements.
843
844 @deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
845 Return the code for statement @code{G}.
846 @end deftypefn
847
848 @deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
849 Return the basic block to which statement @code{G} belongs to.
850 @end deftypefn
851
852 @deftypefn {GIMPLE function} tree gimple_block (gimple g)
853 Return the lexical scope block holding statement @code{G}.
854 @end deftypefn
855
856 @deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
857 Return the type of the main expression computed by @code{STMT}. Return
858 @code{void_type_node} if @code{STMT} computes nothing. This will only return
859 something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
860 @code{GIMPLE_CALL}.  For all other tuple codes, it will return
861 @code{void_type_node}.
862 @end deftypefn
863
864 @deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
865 Return the tree code for the expression computed by @code{STMT}.  This
866 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
867 @code{GIMPLE_COND}.  If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
868 For @code{GIMPLE_COND}, it returns the code of the comparison predicate.
869 For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
870 by the @code{RHS} of the assignment.
871 @end deftypefn
872
873 @deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
874 Set the lexical scope block of @code{G} to @code{BLOCK}.
875 @end deftypefn
876
877 @deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
878 Return locus information for statement @code{G}.
879 @end deftypefn
880
881 @deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
882 Set locus information for statement @code{G}.
883 @end deftypefn
884
885 @deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
886 Return true if @code{G} does not have locus information.
887 @end deftypefn
888
889 @deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
890 Return true if no warnings should be emitted for statement @code{STMT}.
891 @end deftypefn
892
893 @deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
894 Set the visited status on statement @code{STMT} to @code{VISITED_P}.
895 @end deftypefn
896
897 @deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
898 Return the visited status on statement @code{STMT}.
899 @end deftypefn
900
901 @deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
902 Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
903 @end deftypefn
904
905 @deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
906 Return the value of pass local flag @code{PLF} on statement @code{STMT}.
907 @end deftypefn
908
909 @deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
910 Return true if statement @code{G} has register or memory operands.
911 @end deftypefn
912
913 @deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
914 Return true if statement @code{G} has memory operands.
915 @end deftypefn
916
917 @deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
918 Return the number of operands for statement @code{G}.
919 @end deftypefn
920
921 @deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
922 Return the array of operands for statement @code{G}.
923 @end deftypefn
924
925 @deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
926 Return operand @code{I} for statement @code{G}.
927 @end deftypefn
928
929 @deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
930 Return a pointer to operand @code{I} for statement @code{G}.
931 @end deftypefn
932
933 @deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
934 Set operand @code{I} of statement @code{G} to @code{OP}.
935 @end deftypefn
936
937 @deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
938 Return the set of symbols that have had their address taken by
939 @code{STMT}.
940 @end deftypefn
941
942 @deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
943 Return the set of @code{DEF} operands for statement @code{G}.
944 @end deftypefn
945
946 @deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
947 Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
948 @end deftypefn
949
950 @deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
951 Return the set of @code{USE} operands for statement @code{G}.
952 @end deftypefn
953
954 @deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
955 Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
956 @end deftypefn
957
958 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
959 Return the set of @code{VUSE} operands for statement @code{G}.
960 @end deftypefn
961
962 @deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
963 Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
964 @end deftypefn
965
966 @deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
967 Return the set of @code{VDEF} operands for statement @code{G}.
968 @end deftypefn
969
970 @deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
971 Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
972 @end deftypefn
973
974 @deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
975 Return the set of symbols loaded by statement @code{G}.  Each element of
976 the set is the @code{DECL_UID} of the corresponding symbol.
977 @end deftypefn
978
979 @deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
980 Return the set of symbols stored by statement @code{G}.  Each element of
981 the set is the @code{DECL_UID} of the corresponding symbol.
982 @end deftypefn
983
984 @deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
985 Return true if statement @code{G} has operands and the modified field
986 has been set.
987 @end deftypefn
988
989 @deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
990 Return true if statement @code{STMT} contains volatile operands.
991 @end deftypefn
992
993 @deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
994 Return true if statement @code{STMT} contains volatile operands.
995 @end deftypefn
996
997 @deftypefn {GIMPLE function} void update_stmt (gimple s)
998 Mark statement @code{S} as modified, and update it.
999 @end deftypefn
1000
1001 @deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
1002 Update statement @code{S} if it has been marked modified.
1003 @end deftypefn
1004
1005 @deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
1006 Return a deep copy of statement @code{STMT}.
1007 @end deftypefn
1008
1009 @node Tuple specific accessors
1010 @section Tuple specific accessors
1011 @cindex Tuple specific accessors
1012
1013 @menu
1014 * @code{GIMPLE_ASM}::
1015 * @code{GIMPLE_ASSIGN}::
1016 * @code{GIMPLE_BIND}::
1017 * @code{GIMPLE_CALL}::
1018 * @code{GIMPLE_CATCH}::
1019 * @code{GIMPLE_COND}::
1020 * @code{GIMPLE_DEBUG}::
1021 * @code{GIMPLE_EH_FILTER}::
1022 * @code{GIMPLE_LABEL}::
1023 * @code{GIMPLE_GOTO}::
1024 * @code{GIMPLE_NOP}::
1025 * @code{GIMPLE_OMP_ATOMIC_LOAD}::
1026 * @code{GIMPLE_OMP_ATOMIC_STORE}::
1027 * @code{GIMPLE_OMP_CONTINUE}::
1028 * @code{GIMPLE_OMP_CRITICAL}::
1029 * @code{GIMPLE_OMP_FOR}::
1030 * @code{GIMPLE_OMP_MASTER}::
1031 * @code{GIMPLE_OMP_ORDERED}::
1032 * @code{GIMPLE_OMP_PARALLEL}::
1033 * @code{GIMPLE_OMP_RETURN}::
1034 * @code{GIMPLE_OMP_SECTION}::
1035 * @code{GIMPLE_OMP_SECTIONS}::
1036 * @code{GIMPLE_OMP_SINGLE}::
1037 * @code{GIMPLE_PHI}::
1038 * @code{GIMPLE_RESX}::
1039 * @code{GIMPLE_RETURN}::
1040 * @code{GIMPLE_SWITCH}::
1041 * @code{GIMPLE_TRY}::
1042 * @code{GIMPLE_WITH_CLEANUP_EXPR}::
1043 @end menu
1044
1045
1046 @node @code{GIMPLE_ASM}
1047 @subsection @code{GIMPLE_ASM}
1048 @cindex @code{GIMPLE_ASM}
1049
1050 @deftypefn {GIMPLE function} gasm *gimple_build_asm_vec ( @
1051 const char *string, vec<tree, va_gc> *inputs, @
1052 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers, @
1053 vec<tree, va_gc> *labels)
1054 Build a @code{GIMPLE_ASM} statement.  This statement is used for
1055 building in-line assembly constructs.  @code{STRING} is the assembly
1056 code.  @code{INPUTS}, @code{OUTPUTS}, @code{CLOBBERS}  and @code{LABELS}
1057 are the inputs, outputs, clobbered registers and labels.
1058 @end deftypefn
1059
1060 @deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (const gasm *g)
1061 Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
1062 @end deftypefn
1063
1064 @deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (const gasm *g)
1065 Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
1066 @end deftypefn
1067
1068 @deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (const gasm *g)
1069 Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
1070 @end deftypefn
1071
1072 @deftypefn {GIMPLE function} tree gimple_asm_input_op (const gasm *g, @
1073 unsigned index)
1074 Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1075 @end deftypefn
1076
1077 @deftypefn {GIMPLE function} void gimple_asm_set_input_op (gasm *g, @
1078 unsigned index, tree in_op)
1079 Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1080 @end deftypefn
1081
1082 @deftypefn {GIMPLE function} tree gimple_asm_output_op (const gasm *g, @
1083 unsigned index)
1084 Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1085 @end deftypefn
1086
1087 @deftypefn {GIMPLE function} void gimple_asm_set_output_op (gasm *g, @
1088 unsigned index, tree out_op)
1089 Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1090 @end deftypefn
1091
1092 @deftypefn {GIMPLE function} tree gimple_asm_clobber_op (const gasm *g, @
1093 unsigned index)
1094 Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
1095 @end deftypefn
1096
1097 @deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gasm *g, @
1098 unsigned index, tree clobber_op)
1099 Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
1100 @end deftypefn
1101
1102 @deftypefn {GIMPLE function} {const char *} gimple_asm_string (const gasm *g)
1103 Return the string representing the assembly instruction in
1104 @code{GIMPLE_ASM} @code{G}.
1105 @end deftypefn
1106
1107 @deftypefn {GIMPLE function} bool gimple_asm_volatile_p (const gasm *g)
1108 Return true if @code{G} is an asm statement marked volatile.
1109 @end deftypefn
1110
1111 @deftypefn {GIMPLE function} void gimple_asm_set_volatile (gasm *g, @
1112 bool volatile_p)
1113 Mark asm statement @code{G} as volatile or non-volatile based on
1114 @code{VOLATILE_P}.
1115 @end deftypefn
1116
1117 @node @code{GIMPLE_ASSIGN}
1118 @subsection @code{GIMPLE_ASSIGN}
1119 @cindex @code{GIMPLE_ASSIGN}
1120
1121 @deftypefn {GIMPLE function} gassign *gimple_build_assign (tree lhs, tree rhs)
1122 Build a @code{GIMPLE_ASSIGN} statement.  The left-hand side is an lvalue
1123 passed in lhs.  The right-hand side can be either a unary or
1124 binary tree expression.  The expression tree rhs will be
1125 flattened and its operands assigned to the corresponding operand
1126 slots in the new statement.  This function is useful when you
1127 already have a tree expression that you want to convert into a
1128 tuple.  However, try to avoid building expression trees for the
1129 sole purpose of calling this function.  If you already have the
1130 operands in separate trees, it is better to use
1131 @code{gimple_build_assign} with @code{enum tree_code} argument and separate
1132 arguments for each operand.
1133 @end deftypefn
1134
1135 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1136 (tree lhs, enum tree_code subcode, tree op1, tree op2, tree op3)
1137 This function is similar to two operand @code{gimple_build_assign},
1138 but is used to build a @code{GIMPLE_ASSIGN} statement when the operands of the
1139 right-hand side of the assignment are already split into
1140 different operands.
1141
1142 The left-hand side is an lvalue passed in lhs.  Subcode is the
1143 @code{tree_code} for the right-hand side of the assignment.  Op1, op2 and op3
1144 are the operands.
1145 @end deftypefn
1146
1147 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1148 (tree lhs, enum tree_code subcode, tree op1, tree op2)
1149 Like the above 5 operand @code{gimple_build_assign}, but with the last
1150 argument @code{NULL} - this overload should not be used for
1151 @code{GIMPLE_TERNARY_RHS} assignments.
1152 @end deftypefn
1153
1154 @deftypefn {GIMPLE function} gassign *gimple_build_assign @
1155 (tree lhs, enum tree_code subcode, tree op1)
1156 Like the above 4 operand @code{gimple_build_assign}, but with the last
1157 argument @code{NULL} - this overload should be used only for
1158 @code{GIMPLE_UNARY_RHS} and @code{GIMPLE_SINGLE_RHS} assignments.
1159 @end deftypefn
1160
1161 @deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
1162 Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
1163 @code{*SEQ_P}.
1164 @end deftypefn
1165
1166 @code{DST}/@code{SRC} are the destination and source respectively.  You can
1167 pass ungimplified trees in @code{DST} or @code{SRC}, in which
1168 case they will be converted to a gimple operand if necessary.
1169
1170 This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
1171
1172 @deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
1173 Return the code of the expression computed on the @code{RHS} of
1174 assignment statement @code{G}.
1175 @end deftypefn
1176
1177
1178 @deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
1179 Return the gimple rhs class of the code for the expression
1180 computed on the rhs of assignment statement @code{G}.  This will never
1181 return @code{GIMPLE_INVALID_RHS}.
1182 @end deftypefn
1183
1184 @deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
1185 Return the @code{LHS} of assignment statement @code{G}.
1186 @end deftypefn
1187
1188 @deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
1189 Return a pointer to the @code{LHS} of assignment statement @code{G}.
1190 @end deftypefn
1191
1192 @deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
1193 Return the first operand on the @code{RHS} of assignment statement @code{G}.
1194 @end deftypefn
1195
1196 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
1197 Return the address of the first operand on the @code{RHS} of assignment
1198 statement @code{G}.
1199 @end deftypefn
1200
1201 @deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
1202 Return the second operand on the @code{RHS} of assignment statement @code{G}.
1203 @end deftypefn
1204
1205 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
1206 Return the address of the second operand on the @code{RHS} of assignment
1207 statement @code{G}.
1208 @end deftypefn
1209
1210 @deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
1211 Return the third operand on the @code{RHS} of assignment statement @code{G}.
1212 @end deftypefn
1213
1214 @deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
1215 Return the address of the third operand on the @code{RHS} of assignment
1216 statement @code{G}.
1217 @end deftypefn
1218
1219 @deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
1220 Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
1221 @end deftypefn
1222
1223 @deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
1224 Set @code{RHS} to be the first operand on the @code{RHS} of assignment
1225 statement @code{G}.
1226 @end deftypefn
1227
1228 @deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
1229 Set @code{RHS} to be the second operand on the @code{RHS} of assignment
1230 statement @code{G}.
1231 @end deftypefn
1232
1233 @deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
1234 Set @code{RHS} to be the third operand on the @code{RHS} of assignment
1235 statement @code{G}.
1236 @end deftypefn
1237
1238 @deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple s)
1239 Return true if @code{S} is a type-cast assignment.
1240 @end deftypefn
1241
1242
1243 @node @code{GIMPLE_BIND}
1244 @subsection @code{GIMPLE_BIND}
1245 @cindex @code{GIMPLE_BIND}
1246
1247 @deftypefn {GIMPLE function} gbind *gimple_build_bind (tree vars, @
1248 gimple_seq body)
1249 Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
1250 and a body of statements in sequence @code{BODY}.
1251 @end deftypefn
1252
1253 @deftypefn {GIMPLE function} tree gimple_bind_vars (const gbind *g)
1254 Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
1255 @end deftypefn
1256
1257 @deftypefn {GIMPLE function} void gimple_bind_set_vars (gbind *g, tree vars)
1258 Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
1259 statement @code{G}.
1260 @end deftypefn
1261
1262 @deftypefn {GIMPLE function} void gimple_bind_append_vars (gbind *g, tree vars)
1263 Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
1264 statement @code{G}.
1265 @end deftypefn
1266
1267 @deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gbind *g)
1268 Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
1269 @code{G}.
1270 @end deftypefn
1271
1272 @deftypefn {GIMPLE function} void gimple_bind_set_body (gbind *g, @
1273 gimple_seq seq)
1274 Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
1275 @end deftypefn
1276
1277 @deftypefn {GIMPLE function} void gimple_bind_add_stmt (gbind *gs, gimple stmt)
1278 Append a statement to the end of a @code{GIMPLE_BIND}'s body.
1279 @end deftypefn
1280
1281 @deftypefn {GIMPLE function} void gimple_bind_add_seq (gbind *gs, @
1282 gimple_seq seq)
1283 Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
1284 body.
1285 @end deftypefn
1286
1287 @deftypefn {GIMPLE function} tree gimple_bind_block (const gbind *g)
1288 Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
1289 @code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
1290 @end deftypefn
1291
1292 @deftypefn {GIMPLE function} void gimple_bind_set_block (gbind *g, tree block)
1293 Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
1294 statement @code{G}.
1295 @end deftypefn
1296
1297
1298 @node @code{GIMPLE_CALL}
1299 @subsection @code{GIMPLE_CALL}
1300 @cindex @code{GIMPLE_CALL}
1301
1302 @deftypefn {GIMPLE function} gcall *gimple_build_call (tree fn, @
1303 unsigned nargs, ...)
1304 Build a @code{GIMPLE_CALL} statement to function @code{FN}.  The argument @code{FN}
1305 must be either a @code{FUNCTION_DECL} or a gimple call address as
1306 determined by @code{is_gimple_call_addr}.  @code{NARGS} are the number of
1307 arguments.  The rest of the arguments follow the argument @code{NARGS},
1308 and must be trees that are valid as rvalues in gimple (i.e., each
1309 operand is validated with @code{is_gimple_operand}).
1310 @end deftypefn
1311
1312
1313 @deftypefn {GIMPLE function} gcall *gimple_build_call_from_tree (tree call_expr)
1314 Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node.  The arguments and the
1315 function are taken from the expression directly.  This routine
1316 assumes that @code{call_expr} is already in GIMPLE form.  That is, its
1317 operands are GIMPLE values and the function call needs no further
1318 simplification.  All the call flags in @code{call_expr} are copied over
1319 to the new @code{GIMPLE_CALL}.
1320 @end deftypefn
1321
1322 @deftypefn {GIMPLE function} gcall *gimple_build_call_vec (tree fn, @
1323 @code{vec<tree>} args)
1324 Identical to @code{gimple_build_call} but the arguments are stored in a
1325 @code{vec<tree>}.
1326 @end deftypefn
1327
1328 @deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
1329 Return the @code{LHS} of call statement @code{G}.
1330 @end deftypefn
1331
1332 @deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
1333 Return a pointer to the @code{LHS} of call statement @code{G}.
1334 @end deftypefn
1335
1336 @deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
1337 Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
1338 @end deftypefn
1339
1340 @deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
1341 Return the tree node representing the function called by call
1342 statement @code{G}.
1343 @end deftypefn
1344
1345 @deftypefn {GIMPLE function} void gimple_call_set_fn (gcall *g, tree fn)
1346 Set @code{FN} to be the function called by call statement @code{G}.  This has
1347 to be a gimple value specifying the address of the called
1348 function.
1349 @end deftypefn
1350
1351 @deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
1352 If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
1353 Otherwise return @code{NULL}.  This function is analogous to
1354 @code{get_callee_fndecl} in @code{GENERIC}.
1355 @end deftypefn
1356
1357 @deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
1358 Set the called function to @code{FNDECL}.
1359 @end deftypefn
1360
1361 @deftypefn {GIMPLE function} tree gimple_call_return_type (const gcall *g)
1362 Return the type returned by call statement @code{G}.
1363 @end deftypefn
1364
1365 @deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
1366 Return the static chain for call statement @code{G}.
1367 @end deftypefn
1368
1369 @deftypefn {GIMPLE function} void gimple_call_set_chain (gcall *g, tree chain)
1370 Set @code{CHAIN} to be the static chain for call statement @code{G}.
1371 @end deftypefn
1372
1373 @deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
1374 Return the number of arguments used by call statement @code{G}.
1375 @end deftypefn
1376
1377 @deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
1378 Return the argument at position @code{INDEX} for call statement @code{G}.  The
1379 first argument is 0.
1380 @end deftypefn
1381
1382 @deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
1383 Return a pointer to the argument at position @code{INDEX} for call
1384 statement @code{G}.
1385 @end deftypefn
1386
1387 @deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
1388 Set @code{ARG} to be the argument at position @code{INDEX} for call statement
1389 @code{G}.
1390 @end deftypefn
1391
1392 @deftypefn {GIMPLE function} void gimple_call_set_tail (gcall *s)
1393 Mark call statement @code{S} as being a tail call (i.e., a call just
1394 before the exit of a function). These calls are candidate for
1395 tail call optimization.
1396 @end deftypefn
1397
1398 @deftypefn {GIMPLE function} bool gimple_call_tail_p (gcall *s)
1399 Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
1400 @end deftypefn
1401
1402 @deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
1403 Return true if @code{S} is a noreturn call.
1404 @end deftypefn
1405
1406 @deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gcall *stmt, @
1407 bitmap args_to_skip)
1408 Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
1409 in the positions marked by the set @code{ARGS_TO_SKIP}.
1410 @end deftypefn
1411
1412
1413 @node @code{GIMPLE_CATCH}
1414 @subsection @code{GIMPLE_CATCH}
1415 @cindex @code{GIMPLE_CATCH}
1416
1417 @deftypefn {GIMPLE function} gcatch *gimple_build_catch (tree types, @
1418 gimple_seq handler)
1419 Build a @code{GIMPLE_CATCH} statement.  @code{TYPES} are the tree types this
1420 catch handles.  @code{HANDLER} is a sequence of statements with the code
1421 for the handler.
1422 @end deftypefn
1423
1424 @deftypefn {GIMPLE function} tree gimple_catch_types (const gcatch *g)
1425 Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
1426 @end deftypefn
1427
1428 @deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gcatch *g)
1429 Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
1430 @code{G}.
1431 @end deftypefn
1432
1433 @deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gcatch *g)
1434 Return the GIMPLE sequence representing the body of the handler
1435 of @code{GIMPLE_CATCH} statement @code{G}.
1436 @end deftypefn
1437
1438 @deftypefn {GIMPLE function} void gimple_catch_set_types (gcatch *g, tree t)
1439 Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
1440 @end deftypefn
1441
1442 @deftypefn {GIMPLE function} void gimple_catch_set_handler (gcatch *g, @
1443 gimple_seq handler)
1444 Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
1445 @end deftypefn
1446
1447
1448 @node @code{GIMPLE_COND}
1449 @subsection @code{GIMPLE_COND}
1450 @cindex @code{GIMPLE_COND}
1451
1452 @deftypefn {GIMPLE function} gcond *gimple_build_cond ( @
1453 enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
1454 Build a @code{GIMPLE_COND} statement.  @code{A} @code{GIMPLE_COND} statement compares
1455 @code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
1456 the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
1457 @code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR},
1458 @code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc.
1459 @end deftypefn
1460
1461
1462 @deftypefn {GIMPLE function} gcond *gimple_build_cond_from_tree (tree cond, @
1463 tree t_label, tree f_label)
1464 Build a @code{GIMPLE_COND} statement from the conditional expression
1465 tree @code{COND}.  @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
1466 @end deftypefn
1467
1468 @deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
1469 Return the code of the predicate computed by conditional
1470 statement @code{G}.
1471 @end deftypefn
1472
1473 @deftypefn {GIMPLE function} void gimple_cond_set_code (gcond *g, @
1474 enum tree_code code)
1475 Set @code{CODE} to be the predicate code for the conditional statement
1476 @code{G}.
1477 @end deftypefn
1478
1479 @deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
1480 Return the @code{LHS} of the predicate computed by conditional statement
1481 @code{G}.
1482 @end deftypefn
1483
1484 @deftypefn {GIMPLE function} void gimple_cond_set_lhs (gcond *g, tree lhs)
1485 Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
1486 conditional statement @code{G}.
1487 @end deftypefn
1488
1489 @deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
1490 Return the @code{RHS} operand of the predicate computed by conditional
1491 @code{G}.
1492 @end deftypefn
1493
1494 @deftypefn {GIMPLE function} void gimple_cond_set_rhs (gcond *g, tree rhs)
1495 Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
1496 conditional statement @code{G}.
1497 @end deftypefn
1498
1499 @deftypefn {GIMPLE function} tree gimple_cond_true_label (const gcond *g)
1500 Return the label used by conditional statement @code{G} when its
1501 predicate evaluates to true.
1502 @end deftypefn
1503
1504 @deftypefn {GIMPLE function} void gimple_cond_set_true_label (gcond *g, tree label)
1505 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1506 its predicate evaluates to true.
1507 @end deftypefn
1508
1509 @deftypefn {GIMPLE function} void gimple_cond_set_false_label (gcond *g, tree label)
1510 Set @code{LABEL} to be the label used by conditional statement @code{G} when
1511 its predicate evaluates to false.
1512 @end deftypefn
1513
1514 @deftypefn {GIMPLE function} tree gimple_cond_false_label (const gcond *g)
1515 Return the label used by conditional statement @code{G} when its
1516 predicate evaluates to false.
1517 @end deftypefn
1518
1519 @deftypefn {GIMPLE function} void gimple_cond_make_false (gcond *g)
1520 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
1521 @end deftypefn
1522
1523 @deftypefn {GIMPLE function} void gimple_cond_make_true (gcond *g)
1524 Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
1525 @end deftypefn
1526
1527 @node @code{GIMPLE_DEBUG}
1528 @subsection @code{GIMPLE_DEBUG}
1529 @cindex @code{GIMPLE_DEBUG}
1530 @cindex @code{GIMPLE_DEBUG_BIND}
1531
1532 @deftypefn {GIMPLE function} gdebug *gimple_build_debug_bind (tree var, @
1533 tree value, gimple stmt)
1534 Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of
1535 @code{subcode}.  The effect of this statement is to tell debug
1536 information generation machinery that the value of user variable
1537 @code{var} is given by @code{value} at that point, and to remain with
1538 that value until @code{var} runs out of scope, a
1539 dynamically-subsequent debug bind statement overrides the binding, or
1540 conflicting values reach a control flow merge point.  Even if
1541 components of the @code{value} expression change afterwards, the
1542 variable is supposed to retain the same value, though not necessarily
1543 the same location.
1544
1545 It is expected that @code{var} be most often a tree for automatic user
1546 variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the
1547 requirements for gimple registers, but it may also be a tree for a
1548 scalarized component of a user variable (@code{ARRAY_REF},
1549 @code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}).
1550
1551 As for @code{value}, it can be an arbitrary tree expression, but it is
1552 recommended that it be in a suitable form for a gimple assignment
1553 @code{RHS}.  It is not expected that user variables that could appear
1554 as @code{var} ever appear in @code{value}, because in the latter we'd
1555 have their @code{SSA_NAME}s instead, but even if they were not in SSA
1556 form, user variables appearing in @code{value} are to be regarded as
1557 part of the executable code space, whereas those in @code{var} are to
1558 be regarded as part of the source code space.  There is no way to
1559 refer to the value bound to a user variable within a @code{value}
1560 expression.
1561
1562 If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information
1563 generation machinery is informed that the variable @code{var} is
1564 unbound, i.e., that its value is indeterminate, which sometimes means
1565 it is really unavailable, and other times that the compiler could not
1566 keep track of it.
1567
1568 Block and location information for the newly-created stmt are
1569 taken from @code{stmt}, if given.
1570 @end deftypefn
1571
1572 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
1573 Return the user variable @var{var} that is bound at @code{stmt}.
1574 @end deftypefn
1575
1576 @deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
1577 Return the value expression that is bound to a user variable at
1578 @code{stmt}.
1579 @end deftypefn
1580
1581 @deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt)
1582 Return a pointer to the value expression that is bound to a user
1583 variable at @code{stmt}.
1584 @end deftypefn
1585
1586 @deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
1587 Modify the user variable bound at @code{stmt} to @var{var}.
1588 @end deftypefn
1589
1590 @deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
1591 Modify the value bound to the user variable bound at @code{stmt} to
1592 @var{value}.
1593 @end deftypefn
1594
1595 @deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
1596 Modify the value bound to the user variable bound at @code{stmt} so
1597 that the variable becomes unbound.
1598 @end deftypefn
1599
1600 @deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
1601 Return @code{TRUE} if @code{stmt} binds a user variable to a value,
1602 and @code{FALSE} if it unbinds the variable.
1603 @end deftypefn
1604
1605 @node @code{GIMPLE_EH_FILTER}
1606 @subsection @code{GIMPLE_EH_FILTER}
1607 @cindex @code{GIMPLE_EH_FILTER}
1608
1609 @deftypefn {GIMPLE function} geh_filter *gimple_build_eh_filter (tree types, @
1610 gimple_seq failure)
1611 Build a @code{GIMPLE_EH_FILTER} statement.  @code{TYPES} are the filter's
1612 types.  @code{FAILURE} is a sequence with the filter's failure action.
1613 @end deftypefn
1614
1615 @deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
1616 Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
1617 @end deftypefn
1618
1619 @deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
1620 Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
1621 statement @code{G}.
1622 @end deftypefn
1623
1624 @deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
1625 Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
1626 statement fails.
1627 @end deftypefn
1628
1629 @deftypefn {GIMPLE function} void gimple_eh_filter_set_types (geh_filter *g, @
1630 tree types)
1631 Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
1632 @end deftypefn
1633
1634 @deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (geh_filter *g, @
1635 gimple_seq failure)
1636 Set @code{FAILURE} to be the sequence of statements to execute on
1637 failure for @code{GIMPLE_EH_FILTER} @code{G}.
1638 @end deftypefn
1639
1640 @deftypefn {GIMPLE function} tree gimple_eh_must_not_throw_fndecl ( @
1641 geh_mnt *eh_mnt_stmt)
1642 Get the function decl to be called by the MUST_NOT_THROW region.
1643 @end deftypefn
1644
1645 @deftypefn {GIMPLE function} void gimple_eh_must_not_throw_set_fndecl ( @
1646 geh_mnt *eh_mnt_stmt, tree decl)
1647 Set the function decl to be called by GS to DECL.
1648 @end deftypefn
1649
1650
1651 @node @code{GIMPLE_LABEL}
1652 @subsection @code{GIMPLE_LABEL}
1653 @cindex @code{GIMPLE_LABEL}
1654
1655 @deftypefn {GIMPLE function} glabel *gimple_build_label (tree label)
1656 Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
1657 label, @code{LABEL}.
1658 @end deftypefn
1659
1660 @deftypefn {GIMPLE function} tree gimple_label_label (const glabel *g)
1661 Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
1662 @end deftypefn
1663
1664 @deftypefn {GIMPLE function} void gimple_label_set_label (glabel *g, tree label)
1665 Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
1666 statement @code{G}.
1667 @end deftypefn
1668
1669 @node @code{GIMPLE_GOTO}
1670 @subsection @code{GIMPLE_GOTO}
1671 @cindex @code{GIMPLE_GOTO}
1672
1673 @deftypefn {GIMPLE function} ggoto *gimple_build_goto (tree dest)
1674 Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
1675 @end deftypefn
1676
1677 @deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
1678 Return the destination of the unconditional jump @code{G}.
1679 @end deftypefn
1680
1681 @deftypefn {GIMPLE function} void gimple_goto_set_dest (ggoto *g, tree dest)
1682 Set @code{DEST} to be the destination of the unconditional jump @code{G}.
1683 @end deftypefn
1684
1685
1686 @node @code{GIMPLE_NOP}
1687 @subsection @code{GIMPLE_NOP}
1688 @cindex @code{GIMPLE_NOP}
1689
1690 @deftypefn {GIMPLE function} gimple gimple_build_nop (void)
1691 Build a @code{GIMPLE_NOP} statement.
1692 @end deftypefn
1693
1694 @deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
1695 Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
1696 @end deftypefn
1697
1698 @node @code{GIMPLE_OMP_ATOMIC_LOAD}
1699 @subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
1700 @cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
1701
1702 @deftypefn {GIMPLE function} gomp_atomic_load *gimple_build_omp_atomic_load ( @
1703 tree lhs, tree rhs)
1704 Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement.  @code{LHS} is the left-hand
1705 side of the assignment.  @code{RHS} is the right-hand side of the
1706 assignment.
1707 @end deftypefn
1708
1709 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs ( @
1710 gomp_atomic_load *g, tree lhs)
1711 Set the @code{LHS} of an atomic load.
1712 @end deftypefn
1713
1714 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs ( @
1715 const gomp_atomic_load *g)
1716 Get the @code{LHS} of an atomic load.
1717 @end deftypefn
1718
1719 @deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs ( @
1720 gomp_atomic_load *g, tree rhs)
1721 Set the @code{RHS} of an atomic set.
1722 @end deftypefn
1723
1724 @deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs ( @
1725 const gomp_atomic_load *g)
1726 Get the @code{RHS} of an atomic set.
1727 @end deftypefn
1728
1729
1730 @node @code{GIMPLE_OMP_ATOMIC_STORE}
1731 @subsection @code{GIMPLE_OMP_ATOMIC_STORE}
1732 @cindex @code{GIMPLE_OMP_ATOMIC_STORE}
1733
1734 @deftypefn {GIMPLE function} gomp_atomic_store *gimple_build_omp_atomic_store ( @
1735 tree val)
1736 Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
1737 stored.
1738 @end deftypefn
1739
1740 @deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val ( @
1741 gomp_atomic_store *g, tree val)
1742 Set the value being stored in an atomic store.
1743 @end deftypefn
1744
1745 @deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val ( @
1746 const gomp_atomic_store *g)
1747 Return the value being stored in an atomic store.
1748 @end deftypefn
1749
1750 @node @code{GIMPLE_OMP_CONTINUE}
1751 @subsection @code{GIMPLE_OMP_CONTINUE}
1752 @cindex @code{GIMPLE_OMP_CONTINUE}
1753
1754 @deftypefn {GIMPLE function} gomp_continue *gimple_build_omp_continue ( @
1755 tree control_def, tree control_use)
1756 Build a @code{GIMPLE_OMP_CONTINUE} statement.  @code{CONTROL_DEF} is the
1757 definition of the control variable.  @code{CONTROL_USE} is the use of
1758 the control variable.
1759 @end deftypefn
1760
1761 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def ( @
1762 const gomp_continue *s)
1763 Return the definition of the control variable on a
1764 @code{GIMPLE_OMP_CONTINUE} in @code{S}.
1765 @end deftypefn
1766
1767 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr ( @
1768 gomp_continue *s)
1769 Same as above, but return the pointer.
1770 @end deftypefn
1771
1772 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def ( @
1773 gomp_continue *s)
1774 Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
1775 statement in @code{S}.
1776 @end deftypefn
1777
1778 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use ( @
1779 const gomp_continue *s)
1780 Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
1781 in @code{S}.
1782 @end deftypefn
1783
1784 @deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr ( @
1785 gomp_continue *s)
1786 Same as above, but return the pointer.
1787 @end deftypefn
1788
1789 @deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use ( @
1790 gomp_continue *s)
1791 Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
1792 in @code{S}.
1793 @end deftypefn
1794
1795
1796 @node @code{GIMPLE_OMP_CRITICAL}
1797 @subsection @code{GIMPLE_OMP_CRITICAL}
1798 @cindex @code{GIMPLE_OMP_CRITICAL}
1799
1800 @deftypefn {GIMPLE function} gomp_critical *gimple_build_omp_critical ( @
1801 gimple_seq body, tree name)
1802 Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
1803 statements for which only one thread can execute.  @code{NAME} is an
1804 optional identifier for this critical block.
1805 @end deftypefn
1806
1807 @deftypefn {GIMPLE function} tree gimple_omp_critical_name ( @
1808 const gomp_critical *g)
1809 Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
1810 @end deftypefn
1811
1812 @deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr ( @
1813 gomp_critical *g)
1814 Return a pointer to the name associated with @code{OMP} critical
1815 statement @code{G}.
1816 @end deftypefn
1817
1818 @deftypefn {GIMPLE function} void gimple_omp_critical_set_name ( @
1819 gomp_critical *g, tree name)
1820 Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
1821 @end deftypefn
1822
1823 @node @code{GIMPLE_OMP_FOR}
1824 @subsection @code{GIMPLE_OMP_FOR}
1825 @cindex @code{GIMPLE_OMP_FOR}
1826
1827 @deftypefn {GIMPLE function} gomp_for *gimple_build_omp_for (gimple_seq body, @
1828 tree clauses, tree index, tree initial, tree final, tree incr, @
1829 gimple_seq pre_body, enum tree_code omp_for_cond)
1830 Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
1831 inside the for loop.  @code{CLAUSES}, are any of the loop
1832 construct's clauses.  @code{PRE_BODY} is the
1833 sequence of statements that are loop invariant.  @code{INDEX} is the
1834 index variable.  @code{INITIAL} is the initial value of @code{INDEX}.  @code{FINAL} is
1835 final value of @code{INDEX}.  OMP_FOR_COND is the predicate used to
1836 compare @code{INDEX} and @code{FINAL}.  @code{INCR} is the increment expression.
1837 @end deftypefn
1838
1839 @deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
1840 Return the clauses associated with @code{OMP_FOR} @code{G}.
1841 @end deftypefn
1842
1843 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
1844 Return a pointer to the @code{OMP_FOR} @code{G}.
1845 @end deftypefn
1846
1847 @deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
1848 Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
1849 @end deftypefn
1850
1851 @deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
1852 Return the index variable for @code{OMP_FOR} @code{G}.
1853 @end deftypefn
1854
1855 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
1856 Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
1857 @end deftypefn
1858
1859 @deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
1860 Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
1861 @end deftypefn
1862
1863 @deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
1864 Return the initial value for @code{OMP_FOR} @code{G}.
1865 @end deftypefn
1866
1867 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
1868 Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
1869 @end deftypefn
1870
1871 @deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
1872 Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
1873 @end deftypefn
1874
1875 @deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
1876 Return the final value for @code{OMP_FOR} @code{G}.
1877 @end deftypefn
1878
1879 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
1880 turn a pointer to the final value for @code{OMP_FOR} @code{G}.
1881 @end deftypefn
1882
1883 @deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
1884 Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
1885 @end deftypefn
1886
1887 @deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
1888 Return the increment value for @code{OMP_FOR} @code{G}.
1889 @end deftypefn
1890
1891 @deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
1892 Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
1893 @end deftypefn
1894
1895 @deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
1896 Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
1897 @end deftypefn
1898
1899 @deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
1900 Return the sequence of statements to execute before the @code{OMP_FOR}
1901 statement @code{G} starts.
1902 @end deftypefn
1903
1904 @deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
1905 Set @code{PRE_BODY} to be the sequence of statements to execute before
1906 the @code{OMP_FOR} statement @code{G} starts.
1907 @end deftypefn
1908
1909 @deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
1910 Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
1911 @end deftypefn
1912
1913 @deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
1914 Return the condition code associated with @code{OMP_FOR} @code{G}.
1915 @end deftypefn
1916
1917
1918 @node @code{GIMPLE_OMP_MASTER}
1919 @subsection @code{GIMPLE_OMP_MASTER}
1920 @cindex @code{GIMPLE_OMP_MASTER}
1921
1922 @deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
1923 Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
1924 statements to be executed by just the master.
1925 @end deftypefn
1926
1927
1928 @node @code{GIMPLE_OMP_ORDERED}
1929 @subsection @code{GIMPLE_OMP_ORDERED}
1930 @cindex @code{GIMPLE_OMP_ORDERED}
1931
1932 @deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
1933 Build a @code{GIMPLE_OMP_ORDERED} statement.
1934 @end deftypefn
1935
1936 @code{BODY} is the sequence of statements inside a loop that will
1937 executed in sequence.
1938
1939
1940 @node @code{GIMPLE_OMP_PARALLEL}
1941 @subsection @code{GIMPLE_OMP_PARALLEL}
1942 @cindex @code{GIMPLE_OMP_PARALLEL}
1943
1944 @deftypefn {GIMPLE function} gomp_parallel *gimple_build_omp_parallel (@
1945 gimple_seq body, tree clauses, tree child_fn, tree data_arg)
1946 Build a @code{GIMPLE_OMP_PARALLEL} statement.
1947 @end deftypefn
1948
1949 @code{BODY} is sequence of statements which are executed in parallel.
1950 @code{CLAUSES}, are the @code{OMP} parallel construct's clauses.  @code{CHILD_FN} is
1951 the function created for the parallel threads to execute.
1952 @code{DATA_ARG} are the shared data argument(s).
1953
1954 @deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
1955 Return true if @code{OMP} parallel statement @code{G} has the
1956 @code{GF_OMP_PARALLEL_COMBINED} flag set.
1957 @end deftypefn
1958
1959 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
1960 Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
1961 @code{G}.
1962 @end deftypefn
1963
1964 @deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
1965 Return the body for the @code{OMP} statement @code{G}.
1966 @end deftypefn
1967
1968 @deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
1969 Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
1970 @end deftypefn
1971
1972 @deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
1973 Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
1974 @end deftypefn
1975
1976 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr ( @
1977 gomp_parallel *g)
1978 Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
1979 @end deftypefn
1980
1981 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses ( @
1982 gomp_parallel *g, tree clauses)
1983 Set @code{CLAUSES} to be the list of clauses associated with
1984 @code{OMP_PARALLEL} @code{G}.
1985 @end deftypefn
1986
1987 @deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn ( @
1988 const gomp_parallel *g)
1989 Return the child function used to hold the body of @code{OMP_PARALLEL}
1990 @code{G}.
1991 @end deftypefn
1992
1993 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr ( @
1994 gomp_parallel *g)
1995 Return a pointer to the child function used to hold the body of
1996 @code{OMP_PARALLEL} @code{G}.
1997 @end deftypefn
1998
1999 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn ( @
2000 gomp_parallel *g, tree child_fn)
2001 Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
2002 @end deftypefn
2003
2004 @deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg ( @
2005 const gomp_parallel *g)
2006 Return the artificial argument used to send variables and values
2007 from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
2008 @end deftypefn
2009
2010 @deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr ( @
2011 gomp_parallel *g)
2012 Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
2013 @end deftypefn
2014
2015 @deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg ( @
2016 gomp_parallel *g, tree data_arg)
2017 Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
2018 @end deftypefn
2019
2020
2021 @node @code{GIMPLE_OMP_RETURN}
2022 @subsection @code{GIMPLE_OMP_RETURN}
2023 @cindex @code{GIMPLE_OMP_RETURN}
2024
2025 @deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
2026 Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
2027 non-waiting return.
2028 @end deftypefn
2029
2030 @deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
2031 Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
2032 @end deftypefn
2033
2034
2035 @deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
2036 Return true if @code{OMP} return statement @code{G} has the
2037 @code{GF_OMP_RETURN_NOWAIT} flag set.
2038 @end deftypefn
2039
2040 @node @code{GIMPLE_OMP_SECTION}
2041 @subsection @code{GIMPLE_OMP_SECTION}
2042 @cindex @code{GIMPLE_OMP_SECTION}
2043
2044 @deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
2045 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
2046 @end deftypefn
2047
2048 @code{BODY} is the sequence of statements in the section.
2049
2050 @deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
2051 Return true if @code{OMP} section statement @code{G} has the
2052 @code{GF_OMP_SECTION_LAST} flag set.
2053 @end deftypefn
2054
2055 @deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
2056 Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
2057 @end deftypefn
2058
2059 @node @code{GIMPLE_OMP_SECTIONS}
2060 @subsection @code{GIMPLE_OMP_SECTIONS}
2061 @cindex @code{GIMPLE_OMP_SECTIONS}
2062
2063 @deftypefn {GIMPLE function} gomp_sections *gimple_build_omp_sections ( @
2064 gimple_seq body, tree clauses)
2065 Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
2066 section statements.  @code{CLAUSES} are any of the @code{OMP} sections
2067 construct's clauses: private, firstprivate, lastprivate,
2068 reduction, and nowait.
2069 @end deftypefn
2070
2071
2072 @deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
2073 Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
2074 @end deftypefn
2075
2076 @deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
2077 Return the control variable associated with the
2078 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2079 @end deftypefn
2080
2081 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
2082 Return a pointer to the clauses associated with the
2083 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2084 @end deftypefn
2085
2086 @deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
2087 Set @code{CONTROL} to be the set of clauses associated with the
2088 @code{GIMPLE_OMP_SECTIONS} in @code{G}.
2089 @end deftypefn
2090
2091 @deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
2092 Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
2093 @end deftypefn
2094
2095 @deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
2096 Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
2097 @end deftypefn
2098
2099 @deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
2100 Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
2101 @code{G}.
2102 @end deftypefn
2103
2104
2105 @node @code{GIMPLE_OMP_SINGLE}
2106 @subsection @code{GIMPLE_OMP_SINGLE}
2107 @cindex @code{GIMPLE_OMP_SINGLE}
2108
2109 @deftypefn {GIMPLE function} gomp_single *gimple_build_omp_single ( @
2110 gimple_seq body, tree clauses)
2111 Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
2112 statements that will be executed once.  @code{CLAUSES} are any of the
2113 @code{OMP} single construct's clauses: private, firstprivate,
2114 copyprivate, nowait.
2115 @end deftypefn
2116
2117 @deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
2118 Return the clauses associated with @code{OMP_SINGLE} @code{G}.
2119 @end deftypefn
2120
2121 @deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
2122 Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
2123 @end deftypefn
2124
2125 @deftypefn {GIMPLE function} void gimple_omp_single_set_clauses ( @
2126 gomp_single *g, tree clauses)
2127 Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
2128 @end deftypefn
2129
2130
2131 @node @code{GIMPLE_PHI}
2132 @subsection @code{GIMPLE_PHI}
2133 @cindex @code{GIMPLE_PHI}
2134
2135 @deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
2136 Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
2137 @end deftypefn
2138
2139 @deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
2140 Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
2141 be exactly the number of incoming edges for the basic block
2142 holding @code{G}.
2143 @end deftypefn
2144
2145 @deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
2146 Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2147 @end deftypefn
2148
2149 @deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
2150 Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2151 @end deftypefn
2152
2153 @deftypefn {GIMPLE function} void gimple_phi_set_result (gphi *g, tree result)
2154 Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
2155 @end deftypefn
2156
2157 @deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
2158 Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
2159 @code{GIMPLE_PHI} @code{G}.
2160 @end deftypefn
2161
2162 @deftypefn {GIMPLE function} void gimple_phi_set_arg (gphi *g, index, @
2163 struct phi_arg_d * phiarg)
2164 Set @code{PHIARG} to be the argument corresponding to incoming edge
2165 @code{INDEX} for @code{GIMPLE_PHI} @code{G}.
2166 @end deftypefn
2167
2168 @node @code{GIMPLE_RESX}
2169 @subsection @code{GIMPLE_RESX}
2170 @cindex @code{GIMPLE_RESX}
2171
2172 @deftypefn {GIMPLE function} gresx *gimple_build_resx (int region)
2173 Build a @code{GIMPLE_RESX} statement which is a statement.  This
2174 statement is a placeholder for _Unwind_Resume before we know if a
2175 function call or a branch is needed.  @code{REGION} is the exception
2176 region from which control is flowing.
2177 @end deftypefn
2178
2179 @deftypefn {GIMPLE function} int gimple_resx_region (const gresx *g)
2180 Return the region number for @code{GIMPLE_RESX} @code{G}.
2181 @end deftypefn
2182
2183 @deftypefn {GIMPLE function} void gimple_resx_set_region (gresx *g, int region)
2184 Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
2185 @end deftypefn
2186
2187 @node @code{GIMPLE_RETURN}
2188 @subsection @code{GIMPLE_RETURN}
2189 @cindex @code{GIMPLE_RETURN}
2190
2191 @deftypefn {GIMPLE function} greturn *gimple_build_return (tree retval)
2192 Build a @code{GIMPLE_RETURN} statement whose return value is retval.
2193 @end deftypefn
2194
2195 @deftypefn {GIMPLE function} tree gimple_return_retval (const greturn *g)
2196 Return the return value for @code{GIMPLE_RETURN} @code{G}.
2197 @end deftypefn
2198
2199 @deftypefn {GIMPLE function} void gimple_return_set_retval (greturn *g, @
2200 tree retval)
2201 Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
2202 @end deftypefn
2203
2204 @node @code{GIMPLE_SWITCH}
2205 @subsection @code{GIMPLE_SWITCH}
2206 @cindex @code{GIMPLE_SWITCH}
2207
2208 @deftypefn {GIMPLE function} gswitch *gimple_build_switch (tree index, @
2209 tree default_label, @code{vec}<tree> *args)
2210 Build a @code{GIMPLE_SWITCH} statement.  @code{INDEX} is the index variable
2211 to switch on, and @code{DEFAULT_LABEL} represents the default label.
2212 @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
2213 non-default case labels.  Each label is a tree of code @code{CASE_LABEL_EXPR}.
2214 @end deftypefn
2215
2216 @deftypefn {GIMPLE function} unsigned gimple_switch_num_labels ( @
2217 const gswitch *g)
2218 Return the number of labels associated with the switch statement
2219 @code{G}.
2220 @end deftypefn
2221
2222 @deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gswitch *g, @
2223 unsigned nlabels)
2224 Set @code{NLABELS} to be the number of labels for the switch statement
2225 @code{G}.
2226 @end deftypefn
2227
2228 @deftypefn {GIMPLE function} tree gimple_switch_index (const gswitch *g)
2229 Return the index variable used by the switch statement @code{G}.
2230 @end deftypefn
2231
2232 @deftypefn {GIMPLE function} void gimple_switch_set_index (gswitch *g, @
2233 tree index)
2234 Set @code{INDEX} to be the index variable for switch statement @code{G}.
2235 @end deftypefn
2236
2237 @deftypefn {GIMPLE function} tree gimple_switch_label (const gswitch *g, @
2238 unsigned index)
2239 Return the label numbered @code{INDEX}. The default label is 0, followed
2240 by any labels in a switch statement.
2241 @end deftypefn
2242
2243 @deftypefn {GIMPLE function} void gimple_switch_set_label (gswitch *g, @
2244 unsigned index, tree label)
2245 Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
2246 label.
2247 @end deftypefn
2248
2249 @deftypefn {GIMPLE function} tree gimple_switch_default_label ( @
2250 const gswitch *g)
2251 Return the default label for a switch statement.
2252 @end deftypefn
2253
2254 @deftypefn {GIMPLE function} void gimple_switch_set_default_label (gswitch *g, @
2255 tree label)
2256 Set the default label for a switch statement.
2257 @end deftypefn
2258
2259
2260 @node @code{GIMPLE_TRY}
2261 @subsection @code{GIMPLE_TRY}
2262 @cindex @code{GIMPLE_TRY}
2263
2264 @deftypefn {GIMPLE function} gtry *gimple_build_try (gimple_seq eval, @
2265 gimple_seq cleanup, unsigned int kind)
2266 Build a @code{GIMPLE_TRY} statement.  @code{EVAL} is a sequence with the
2267 expression to evaluate.  @code{CLEANUP} is a sequence of statements to
2268 run at clean-up time.  @code{KIND} is the enumeration value
2269 @code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct
2270 or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
2271 construct.
2272 @end deftypefn
2273
2274 @deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
2275 Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
2276 either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
2277 @end deftypefn
2278
2279 @deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
2280 Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2281 @end deftypefn
2282
2283 @deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
2284 Return the sequence of statements used as the body for @code{GIMPLE_TRY}
2285 @code{G}.
2286 @end deftypefn
2287
2288 @deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
2289 Return the sequence of statements used as the cleanup body for
2290 @code{GIMPLE_TRY} @code{G}.
2291 @end deftypefn
2292
2293 @deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
2294 bool catch_is_cleanup)
2295 Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
2296 @end deftypefn
2297
2298 @deftypefn {GIMPLE function} void gimple_try_set_eval (gtry *g, gimple_seq eval)
2299 Set @code{EVAL} to be the sequence of statements to use as the body for
2300 @code{GIMPLE_TRY} @code{G}.
2301 @end deftypefn
2302
2303 @deftypefn {GIMPLE function} void gimple_try_set_cleanup (gtry *g, @
2304 gimple_seq cleanup)
2305 Set @code{CLEANUP} to be the sequence of statements to use as the
2306 cleanup body for @code{GIMPLE_TRY} @code{G}.
2307 @end deftypefn
2308
2309 @node @code{GIMPLE_WITH_CLEANUP_EXPR}
2310 @subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
2311 @cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
2312
2313 @deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
2314 Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement.  @code{CLEANUP} is the
2315 clean-up expression.
2316 @end deftypefn
2317
2318 @deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
2319 Return the cleanup sequence for cleanup statement @code{G}.
2320 @end deftypefn
2321
2322 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
2323 Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
2324 @end deftypefn
2325
2326 @deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
2327 Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2328 @end deftypefn
2329
2330 @deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
2331 Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
2332 @end deftypefn
2333
2334
2335 @node GIMPLE sequences
2336 @section GIMPLE sequences
2337 @cindex GIMPLE sequences
2338
2339 GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
2340 used in @code{GENERIC}.  They are used to chain statements together, and
2341 when used in conjunction with sequence iterators, provide a
2342 framework for iterating through statements.
2343
2344 GIMPLE sequences are of type struct @code{gimple_sequence}, but are more
2345 commonly passed by reference to functions dealing with sequences.
2346 The type for a sequence pointer is @code{gimple_seq} which is the same
2347 as struct @code{gimple_sequence} *.  When declaring a local sequence,
2348 you can define a local variable of type struct @code{gimple_sequence}.
2349 When declaring a sequence allocated on the garbage collected
2350 heap, use the function @code{gimple_seq_alloc} documented below.
2351
2352 There are convenience functions for iterating through sequences
2353 in the section entitled Sequence Iterators.
2354
2355 Below is a list of functions to manipulate and query sequences.
2356
2357 @deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
2358 Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
2359 not @code{NULL}.  If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
2360 @end deftypefn
2361
2362 @deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src)
2363 Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not
2364 @code{NULL}.  If *@code{DEST} is @code{NULL}, allocate a new sequence before
2365 appending.
2366 @end deftypefn
2367
2368 @deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src)
2369 Perform a deep copy of sequence @code{SRC} and return the result.
2370 @end deftypefn
2371
2372 @deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq)
2373 Reverse the order of the statements in the sequence @code{SEQ}.  Return
2374 @code{SEQ}.
2375 @end deftypefn
2376
2377 @deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
2378 Return the first statement in sequence @code{S}.
2379 @end deftypefn
2380
2381 @deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
2382 Return the last statement in sequence @code{S}.
2383 @end deftypefn
2384
2385 @deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
2386 Set the last statement in sequence @code{S} to the statement in @code{LAST}.
2387 @end deftypefn
2388
2389 @deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
2390 Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
2391 @end deftypefn
2392
2393 @deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s)
2394 Initialize sequence @code{S} to an empty sequence.
2395 @end deftypefn
2396
2397 @deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void)
2398 Allocate a new sequence in the garbage collected store and return
2399 it.
2400 @end deftypefn
2401
2402 @deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src)
2403 Copy the sequence @code{SRC} into the sequence @code{DEST}.
2404 @end deftypefn
2405
2406 @deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s)
2407 Return true if the sequence @code{S} is empty.
2408 @end deftypefn
2409
2410 @deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb)
2411 Returns the sequence of statements in @code{BB}.
2412 @end deftypefn
2413
2414 @deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq)
2415 Sets the sequence of statements in @code{BB} to @code{SEQ}.
2416 @end deftypefn
2417
2418 @deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq)
2419 Determine whether @code{SEQ} contains exactly one statement.
2420 @end deftypefn
2421
2422 @node Sequence iterators
2423 @section Sequence iterators
2424 @cindex Sequence iterators
2425
2426 Sequence iterators are convenience constructs for iterating
2427 through statements in a sequence.  Given a sequence @code{SEQ}, here is
2428 a typical use of gimple sequence iterators:
2429
2430 @smallexample
2431 gimple_stmt_iterator gsi;
2432
2433 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
2434   @{
2435     gimple g = gsi_stmt (gsi);
2436     /* Do something with gimple statement @code{G}.  */
2437   @}
2438 @end smallexample
2439
2440 Backward iterations are possible:
2441
2442 @smallexample
2443         for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi))
2444 @end smallexample
2445
2446 Forward and backward iterations on basic blocks are possible with
2447 @code{gsi_start_bb} and @code{gsi_last_bb}.
2448
2449 In the documentation below we sometimes refer to enum
2450 @code{gsi_iterator_update}.  The valid options for this enumeration are:
2451
2452 @itemize @bullet
2453 @item @code{GSI_NEW_STMT}
2454 Only valid when a single statement is added.  Move the iterator to it.
2455
2456 @item @code{GSI_SAME_STMT}
2457 Leave the iterator at the same statement.
2458
2459 @item @code{GSI_CONTINUE_LINKING}
2460 Move iterator to whatever position is suitable for linking other
2461 statements in the same direction.
2462 @end itemize
2463
2464 Below is a list of the functions used to manipulate and use
2465 statement iterators.
2466
2467 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq)
2468 Return a new iterator pointing to the sequence @code{SEQ}'s first
2469 statement.  If @code{SEQ} is empty, the iterator's basic block is @code{NULL}.
2470 Use @code{gsi_start_bb} instead when the iterator needs to always have
2471 the correct basic block set.
2472 @end deftypefn
2473
2474 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb)
2475 Return a new iterator pointing to the first statement in basic
2476 block @code{BB}.
2477 @end deftypefn
2478
2479 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq)
2480 Return a new iterator initially pointing to the last statement of
2481 sequence @code{SEQ}.  If @code{SEQ} is empty, the iterator's basic block is
2482 @code{NULL}.  Use @code{gsi_last_bb} instead when the iterator needs to always
2483 have the correct basic block set.
2484 @end deftypefn
2485
2486 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb)
2487 Return a new iterator pointing to the last statement in basic
2488 block @code{BB}.
2489 @end deftypefn
2490
2491 @deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i)
2492 Return @code{TRUE} if at the end of @code{I}.
2493 @end deftypefn
2494
2495 @deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i)
2496 Return @code{TRUE} if we're one statement before the end of @code{I}.
2497 @end deftypefn
2498
2499 @deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i)
2500 Advance the iterator to the next gimple statement.
2501 @end deftypefn
2502
2503 @deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i)
2504 Advance the iterator to the previous gimple statement.
2505 @end deftypefn
2506
2507 @deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
2508 Return the current stmt.
2509 @end deftypefn
2510
2511 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb)
2512 Return a block statement iterator that points to the first
2513 non-label statement in block @code{BB}.
2514 @end deftypefn
2515
2516 @deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i)
2517 Return a pointer to the current stmt.
2518 @end deftypefn
2519
2520 @deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i)
2521 Return the basic block associated with this iterator.
2522 @end deftypefn
2523
2524 @deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i)
2525 Return the sequence associated with this iterator.
2526 @end deftypefn
2527
2528 @deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info)
2529 Remove the current stmt from the sequence.  The iterator is
2530 updated to point to the next statement.  When @code{REMOVE_EH_INFO} is
2531 true we remove the statement pointed to by iterator @code{I} from the @code{EH}
2532 tables.  Otherwise we do not modify the @code{EH} tables.  Generally,
2533 @code{REMOVE_EH_INFO} should be true when the statement is going to be
2534 removed from the @code{IL} and not reinserted elsewhere.
2535 @end deftypefn
2536
2537 @deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode)
2538 Links the sequence of statements @code{SEQ} before the statement pointed
2539 by iterator @code{I}.  @code{MODE} indicates what to do with the iterator
2540 after insertion (see @code{enum gsi_iterator_update} above).
2541 @end deftypefn
2542
2543 @deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
2544 Links statement @code{G} before the statement pointed-to by iterator @code{I}.
2545 Updates iterator @code{I} according to @code{MODE}.
2546 @end deftypefn
2547
2548 @deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, @
2549 gimple_seq seq, enum gsi_iterator_update mode)
2550 Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
2551 @code{MODE} is as in @code{gsi_insert_after}.
2552 @end deftypefn
2553
2554 @deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
2555 gimple g, enum gsi_iterator_update mode)
2556 Links statement @code{G} after the statement pointed-to by iterator @code{I}.
2557 @code{MODE} is as in @code{gsi_insert_after}.
2558 @end deftypefn
2559
2560 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i)
2561 Move all statements in the sequence after @code{I} to a new sequence.
2562 Return this new sequence.
2563 @end deftypefn
2564
2565 @deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i)
2566 Move all statements in the sequence before @code{I} to a new sequence.
2567 Return this new sequence.
2568 @end deftypefn
2569
2570 @deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @
2571 gimple stmt, bool update_eh_info)
2572 Replace the statement pointed-to by @code{I} to @code{STMT}.  If @code{UPDATE_EH_INFO}
2573 is true, the exception handling information of the original
2574 statement is moved to the new statement.
2575 @end deftypefn
2576
2577 @deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
2578 gimple stmt, enum gsi_iterator_update mode)
2579 Insert statement @code{STMT} before the statement pointed-to by iterator
2580 @code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
2581 specifies how to update iterator @code{I} after insertion (see enum
2582 @code{gsi_iterator_update}).
2583 @end deftypefn
2584
2585 @deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, @
2586 gimple_seq seq, enum gsi_iterator_update mode)
2587 Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
2588 @end deftypefn
2589
2590 @deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
2591 gimple stmt, enum gsi_iterator_update mode)
2592 Insert statement @code{STMT} after the statement pointed-to by iterator
2593 @code{I}, update @code{STMT}'s basic block and scan it for new operands.  @code{MODE}
2594 specifies how to update iterator @code{I} after insertion (see enum
2595 @code{gsi_iterator_update}).
2596 @end deftypefn
2597
2598 @deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, @
2599 gimple_seq seq, enum gsi_iterator_update mode)
2600 Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
2601 @end deftypefn
2602
2603 @deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
2604 Finds iterator for @code{STMT}.
2605 @end deftypefn
2606
2607 @deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, @
2608 gimple_stmt_iterator *to)
2609 Move the statement at @code{FROM} so it comes right after the statement
2610 at @code{TO}.
2611 @end deftypefn
2612
2613 @deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, @
2614 gimple_stmt_iterator *to)
2615 Move the statement at @code{FROM} so it comes right before the statement
2616 at @code{TO}.
2617 @end deftypefn
2618
2619 @deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, @
2620 basic_block bb)
2621 Move the statement at @code{FROM} to the end of basic block @code{BB}.
2622 @end deftypefn
2623
2624 @deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
2625 Add @code{STMT} to the pending list of edge @code{E}.  No actual insertion is
2626 made until a call to @code{gsi_commit_edge_inserts}() is made.
2627 @end deftypefn
2628
2629 @deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq)
2630 Add the sequence of statements in @code{SEQ} to the pending list of edge
2631 @code{E}.  No actual insertion is made until a call to
2632 @code{gsi_commit_edge_inserts}() is made.
2633 @end deftypefn
2634
2635 @deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
2636 Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}.  If a new
2637 block has to be created, it is returned.
2638 @end deftypefn
2639
2640 @deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
2641 Commit insertions pending at edge @code{E}.  If a new block is created,
2642 set @code{NEW_BB} to this block, otherwise set it to @code{NULL}.
2643 @end deftypefn
2644
2645 @deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void)
2646 This routine will commit all pending edge insertions, creating
2647 any new basic blocks which are necessary.
2648 @end deftypefn
2649
2650
2651 @node Adding a new GIMPLE statement code
2652 @section Adding a new GIMPLE statement code
2653 @cindex Adding a new GIMPLE statement code
2654
2655 The first step in adding a new GIMPLE statement code, is
2656 modifying the file @code{gimple.def}, which contains all the GIMPLE
2657 codes.  Then you must add a corresponding gimple_statement_base subclass
2658 located in @code{gimple.h}.  This in turn, will require you to add a
2659 corresponding @code{GTY} tag in @code{gsstruct.def}, and code to handle
2660 this tag in @code{gss_for_code} which is located in @code{gimple.c}.
2661
2662 In order for the garbage collector to know the size of the
2663 structure you created in @code{gimple.h}, you need to add a case to
2664 handle your new GIMPLE statement in @code{gimple_size} which is located
2665 in @code{gimple.c}.
2666
2667 You will probably want to create a function to build the new
2668 gimple statement in @code{gimple.c}.  The function should be called
2669 @code{gimple_build_@var{new-tuple-name}}, and should return the new tuple
2670 as a pointer to the appropriate gimple_statement_base subclass.
2671
2672 If your new statement requires accessors for any members or
2673 operands it may have, put simple inline accessors in
2674 @code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
2675 corresponding prototype in @code{gimple.h}.
2676
2677 You should add the new statement subclass to the class hierarchy diagram
2678 in @code{gimple.texi}.
2679
2680
2681 @node Statement and operand traversals
2682 @section Statement and operand traversals
2683 @cindex Statement and operand traversals
2684
2685 There are two functions available for walking statements and
2686 sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
2687 accordingly, and a third function for walking the operands in a
2688 statement: @code{walk_gimple_op}.
2689
2690 @deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, @
2691   walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2692 This function is used to walk the current statement in @code{GSI},
2693 optionally using traversal state stored in @code{WI}.  If @code{WI} is @code{NULL}, no
2694 state is kept during the traversal.
2695
2696 The callback @code{CALLBACK_STMT} is called.  If @code{CALLBACK_STMT} returns
2697 true, it means that the callback function has handled all the
2698 operands of the statement and it is not necessary to walk its
2699 operands.
2700
2701 If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is
2702 called on each operand of the statement via @code{walk_gimple_op}.  If
2703 @code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining
2704 operands are not scanned.
2705
2706 The return value is that returned by the last call to
2707 @code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified.
2708 @end deftypefn
2709
2710
2711 @deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @
2712   walk_tree_fn callback_op, struct walk_stmt_info *wi)
2713 Use this function to walk the operands of statement @code{STMT}.  Every
2714 operand is walked via @code{walk_tree} with optional state information
2715 in @code{WI}.
2716
2717 @code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}.
2718 Additional parameters to @code{walk_tree} must be stored in @code{WI}.  For
2719 each operand @code{OP}, @code{walk_tree} is called as:
2720
2721 @smallexample
2722 walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{PSET})
2723 @end smallexample
2724
2725 If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining
2726 operands are not scanned.  The return value is that returned by
2727 the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is
2728 specified.
2729 @end deftypefn
2730
2731
2732 @deftypefn {GIMPLE function} tree walk_gimple_seq (gimple_seq seq, @
2733   walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
2734 This function walks all the statements in the sequence @code{SEQ}
2735 calling @code{walk_gimple_stmt} on each one.  @code{WI} is as in
2736 @code{walk_gimple_stmt}.  If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk
2737 is stopped and the value returned.  Otherwise, all the statements
2738 are walked and @code{NULL_TREE} returned.
2739 @end deftypefn