* testsuite/libgomp.oacc-c-c++-common/collapse-2.c: Sequential
[official-gcc.git] / gcc / gimple.def
blobd3ca402aea79b5391f7fe2b4e94d719769797e5c
1 /* This file contains the definitions of the GIMPLE IR tuples used in GCC.
3 Copyright (C) 2007-2015 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* The format of this file is
23 DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol). */
26 /* Error marker. This is used in similar ways as ERROR_MARK in tree.def. */
27 DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE)
29 /* IMPORTANT. Do not rearrange the codes between GIMPLE_COND and
30 GIMPLE_RETURN. The ordering is exposed by gimple_has_ops calls.
31 These are all the GIMPLE statements with register operands. */
33 /* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL>
34 represents the conditional jump:
36 if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL
38 COND_CODE is the tree code used as the comparison predicate. It
39 must be of class tcc_comparison.
41 OP1 and OP2 are the operands used in the comparison. They must be
42 accepted by is_gimple_operand.
44 TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the
45 jump target for the comparison. */
46 DEFGSCODE(GIMPLE_COND, "gimple_cond", GSS_WITH_OPS)
48 /* GIMPLE_DEBUG represents a debug statement. */
49 DEFGSCODE(GIMPLE_DEBUG, "gimple_debug", GSS_WITH_OPS)
51 /* GIMPLE_GOTO <TARGET> represents unconditional jumps.
52 TARGET is a LABEL_DECL or an expression node for computed GOTOs. */
53 DEFGSCODE(GIMPLE_GOTO, "gimple_goto", GSS_WITH_OPS)
55 /* GIMPLE_LABEL <LABEL> represents label statements. LABEL is a
56 LABEL_DECL representing a jump target. */
57 DEFGSCODE(GIMPLE_LABEL, "gimple_label", GSS_WITH_OPS)
59 /* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the
60 multiway branch:
62 switch (INDEX)
64 case LAB1: ...; break;
65 ...
66 case LABN: ...; break;
67 default: ...
70 INDEX is the variable evaluated to decide which label to jump to.
72 DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels.
73 They must be CASE_LABEL_EXPR nodes. */
74 DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", GSS_WITH_OPS)
76 /* IMPORTANT.
78 Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN.
79 It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE
80 statements with memory and register operands. */
82 /* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment
83 statement
85 LHS = RHS1 SUBCODE RHS2.
87 SUBCODE is the tree code for the expression computed by the RHS of the
88 assignment. It must be one of the tree codes accepted by
89 get_gimple_rhs_class. If LHS is not a gimple register according to
90 is_gimple_reg, SUBCODE must be of class GIMPLE_SINGLE_RHS.
92 LHS is the operand on the LHS of the assignment. It must be a tree node
93 accepted by is_gimple_lvalue.
95 RHS1 is the first operand on the RHS of the assignment. It must always be
96 present. It must be a tree node accepted by is_gimple_val.
98 RHS2 is the second operand on the RHS of the assignment. It must be a tree
99 node accepted by is_gimple_val. This argument exists only if SUBCODE is
100 of class GIMPLE_BINARY_RHS. */
101 DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign", GSS_WITH_MEM_OPS)
103 /* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP>
104 represents inline assembly statements.
106 STRING is the string containing the assembly statements.
107 I1 ... IN are the N input operands.
108 O1 ... OM are the M output operands.
109 C1 ... CP are the P clobber operands.
110 L1 ... LQ are the Q label operands. */
111 DEFGSCODE(GIMPLE_ASM, "gimple_asm", GSS_ASM)
113 /* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
114 calls.
116 FN is the callee. It must be accepted by is_gimple_call_addr.
118 LHS is the operand where the return value from FN is stored. It may
119 be NULL.
121 ARG1 ... ARGN are the arguments. They must all be accepted by
122 is_gimple_operand.
124 CHAIN is the optional static chain link for nested functions. */
125 DEFGSCODE(GIMPLE_CALL, "gimple_call", GSS_CALL)
127 /* GIMPLE_TRANSACTION <BODY, LABEL> represents __transaction_atomic and
128 __transaction_relaxed blocks.
129 BODY is the sequence of statements inside the transaction.
130 LABEL is a label for the statement immediately following the
131 transaction. This is before RETURN so that it has MEM_OPS,
132 so that it can clobber global memory. */
133 DEFGSCODE(GIMPLE_TRANSACTION, "gimple_transaction", GSS_TRANSACTION)
135 /* GIMPLE_RETURN <RETVAL> represents return statements.
137 RETVAL is the value to return or NULL. If a value is returned it
138 must be accepted by is_gimple_operand. */
139 DEFGSCODE(GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS)
141 /* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope.
142 VARS is the set of variables declared in that scope.
143 BLOCK is the symbol binding block used for debug information.
144 BODY is the sequence of statements in the scope. */
145 DEFGSCODE(GIMPLE_BIND, "gimple_bind", GSS_BIND)
147 /* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler.
148 TYPES is the type (or list of types) handled. HANDLER is the
149 sequence of statements that handle these types. */
150 DEFGSCODE(GIMPLE_CATCH, "gimple_catch", GSS_CATCH)
152 /* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception
153 specification. TYPES is a list of allowed types and FAILURE is the
154 sequence of statements to execute on failure. */
155 DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER)
157 /* GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier.
158 DECL is a noreturn function decl taking no arguments that will
159 be invoked if an exception propagates to this point. */
160 DEFGSCODE(GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT)
162 /* GIMPLE_EH_ELSE <N_BODY, E_BODY> must be the sole contents of
163 a GIMPLE_TRY_FINALLY node. For all normal exits from the try block,
164 N_BODY is run; for all exception exits from the try block,
165 E_BODY is run. */
166 DEFGSCODE(GIMPLE_EH_ELSE, "gimple_eh_else", GSS_EH_ELSE)
168 /* GIMPLE_RESX resumes execution after an exception. */
169 DEFGSCODE(GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL)
171 /* GIMPLE_EH_DISPATCH demultiplexes an exception edge based on
172 the FILTER argument. */
173 DEFGSCODE(GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL)
175 /* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node
177 RESULT = PHI <ARG1, ..., ARGN>
179 RESULT is the SSA name created by this PHI node.
181 ARG1 ... ARGN are the arguments to the PHI node. N must be
182 exactly the same as the number of incoming edges to the basic block
183 holding the PHI node. Every argument is either an SSA name or a
184 tree node of class tcc_constant. */
185 DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI)
187 /* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
188 represents a try/catch or a try/finally statement.
190 TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.
192 EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.
194 CLEANUP is the sequence of statements to execute according to
195 TRY_KIND. If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected
196 if an exception is thrown during execution of EVAL. If TRY_KIND is
197 GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
198 (regardless of whether EVAL finished normally, or jumped out or an
199 exception was thrown). */
200 DEFGSCODE(GIMPLE_TRY, "gimple_try", GSS_TRY)
202 /* GIMPLE_NOP represents the "do nothing" statement. */
203 DEFGSCODE(GIMPLE_NOP, "gimple_nop", GSS_BASE)
206 /* IMPORTANT.
208 Do not rearrange any of the GIMPLE_OMP_* codes. This ordering is
209 exposed by the range check in gimple_omp_subcode(). */
212 /* Tuples used for lowering of OMP_ATOMIC. Although the form of the OMP_ATOMIC
213 expression is very simple (just in form mem op= expr), various implicit
214 conversions may cause the expression to become more complex, so that it does
215 not fit the gimple grammar very well. To overcome this problem, OMP_ATOMIC
216 is rewritten as a sequence of two codes in gimplification:
218 GIMPLE_OMP_LOAD (tmp, mem)
219 val = some computations involving tmp;
220 GIMPLE_OMP_STORE (val). */
221 DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load",
222 GSS_OMP_ATOMIC_LOAD)
223 DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store",
224 GSS_OMP_ATOMIC_STORE_LAYOUT)
226 /* GIMPLE_OMP_CONTINUE marks the location of the loop or sections
227 iteration in partially lowered OpenMP code. */
228 DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE)
230 /* GIMPLE_OMP_CRITICAL <NAME, BODY> represents
232 #pragma omp critical [name]
234 NAME is the name given to the critical section.
235 BODY is the sequence of statements that are inside the critical section. */
236 DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL)
238 /* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY>
239 represents
241 PRE_BODY
242 #pragma omp for [clause1 ... clauseN]
243 for (INDEX = INITIAL; INDEX COND FINAL; INDEX {+=,-=} INCR)
244 BODY
246 Likewise for:
247 #pragma acc loop [clause1 ... clauseN]
249 BODY is the loop body.
251 CLAUSES is the list of clauses.
253 INDEX must be an integer or pointer variable, which is implicitly thread
254 private. It must be accepted by is_gimple_operand.
256 INITIAL is the initial value given to INDEX. It must be
257 accepted by is_gimple_operand.
259 FINAL is the final value that INDEX should take. It must
260 be accepted by is_gimple_operand.
262 COND is the condition code for the controlling predicate. It must
263 be one of { <, >, <=, >= }
265 INCR is the loop index increment. It must be tree node of type
266 tcc_constant.
268 PRE_BODY is a landing pad filled by the gimplifier with things from
269 INIT, COND, and INCR that are technically part of the OMP_FOR
270 structured block, but are evaluated before the loop body begins.
272 INITIAL, FINAL and INCR are required to be loop invariant integer
273 expressions that are evaluated without any synchronization.
274 The evaluation order, frequency of evaluation and side-effects are
275 unspecified by the standards. */
276 DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR)
278 /* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master.
279 BODY is the sequence of statements to execute in the master section. */
280 DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP)
282 /* GIMPLE_OMP_TASKGROUP <BODY> represents #pragma omp taskgroup.
283 BODY is the sequence of statements to execute in the taskgroup section. */
284 DEFGSCODE(GIMPLE_OMP_TASKGROUP, "gimple_omp_taskgroup", GSS_OMP)
286 /* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents
288 #pragma omp parallel [CLAUSES]
289 BODY
291 BODY is a the sequence of statements to be executed by all threads.
293 CLAUSES is an OMP_CLAUSE chain with all the clauses.
295 CHILD_FN is set when outlining the body of the parallel region.
296 All the statements in BODY are moved into this newly created
297 function when converting OMP constructs into low-GIMPLE.
299 DATA_ARG is a local variable in the parent function containing data
300 to be shared with CHILD_FN. This is used to implement all the data
301 sharing clauses. */
302 DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL_LAYOUT)
304 /* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN,
305 ARG_SIZE, ARG_ALIGN> represents
307 #pragma omp task [CLAUSES]
308 BODY
310 BODY is a the sequence of statements to be executed by all threads.
312 CLAUSES is an OMP_CLAUSE chain with all the clauses.
314 CHILD_FN is set when outlining the body of the explicit task region.
315 All the statements in BODY are moved into this newly created
316 function when converting OMP constructs into low-GIMPLE.
318 DATA_ARG is a local variable in the parent function containing data
319 to be shared with CHILD_FN. This is used to implement all the data
320 sharing clauses.
322 COPY_FN is set when outlining the firstprivate var initialization.
323 All the needed statements are emitted into the newly created
324 function, or when only memcpy is needed, it is NULL.
326 ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming
327 data area allocated by GOMP_task and passed to CHILD_FN. */
328 DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK)
330 /* OMP_RETURN marks the end of an OpenMP directive. */
331 DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_OMP_ATOMIC_STORE_LAYOUT)
333 /* OMP_SECTION <BODY> represents #pragma omp section.
334 BODY is the sequence of statements in the section body. */
335 DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP)
337 /* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections.
339 BODY is the sequence of statements in the sections body.
340 CLAUSES is an OMP_CLAUSE chain holding the list of associated clauses.
341 CONTROL is a VAR_DECL used for deciding which of the sections
342 to execute. */
343 DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS)
345 /* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after
346 OMP_SECTIONS. It represents the GIMPLE_SWITCH used to decide which
347 branch is taken. */
348 DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE)
350 /* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single
351 BODY is the sequence of statements inside the single section.
352 CLAUSES is an OMP_CLAUSE chain holding the associated clauses. */
353 DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE_LAYOUT)
355 /* GIMPLE_OMP_TARGET <BODY, CLAUSES, CHILD_FN> represents
356 #pragma acc {kernels,parallel,data,enter data,exit data,update}
357 #pragma omp target {,data,update}
358 BODY is the sequence of statements inside the construct
359 (NULL for some variants).
360 CLAUSES is an OMP_CLAUSE chain holding the associated clauses.
361 CHILD_FN is set when outlining the body of the offloaded region.
362 All the statements in BODY are moved into this newly created
363 function when converting OMP constructs into low-GIMPLE.
364 DATA_ARG is a vec of 3 local variables in the parent function
365 containing data to be mapped to CHILD_FN. This is used to
366 implement the MAP clauses. */
367 DEFGSCODE(GIMPLE_OMP_TARGET, "gimple_omp_target", GSS_OMP_PARALLEL_LAYOUT)
369 /* GIMPLE_OMP_TEAMS <BODY, CLAUSES> represents #pragma omp teams
370 BODY is the sequence of statements inside the single section.
371 CLAUSES is an OMP_CLAUSE chain holding the associated clauses. */
372 DEFGSCODE(GIMPLE_OMP_TEAMS, "gimple_omp_teams", GSS_OMP_SINGLE_LAYOUT)
374 /* GIMPLE_OMP_ORDERED <BODY, CLAUSES> represents #pragma omp ordered.
375 BODY is the sequence of statements to execute in the ordered section.
376 CLAUSES is an OMP_CLAUSE chain holding the associated clauses. */
377 DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP_SINGLE_LAYOUT)
379 /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction.
381 PREDICT is one of the predictors from predict.def.
383 OUTCOME is NOT_TAKEN or TAKEN. */
384 DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", GSS_BASE)
386 /* This node represents a cleanup expression. It is ONLY USED INTERNALLY
387 by the gimplifier as a placeholder for cleanups, and its uses will be
388 cleaned up by the time gimplification is done.
390 This tuple should not exist outside of the gimplifier proper. */
391 DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE)