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