|
0
|
1 /* This file contains the definitions of the GIMPLE IR tuples used in GCC.
|
|
|
2
|
|
|
3 Copyright (C) 2007, 2008 Free Software Foundation, Inc.
|
|
|
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
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.
|
|
|
12
|
|
|
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.
|
|
|
17
|
|
|
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/>. */
|
|
|
21
|
|
|
22 /* The format of this file is
|
|
|
23 DEFGSCODE(GIMPLE_symbol, printable name, structure).
|
|
|
24
|
|
|
25 Where symbol is the enumeration name without the ``GIMPLE_''.
|
|
|
26 The argument STRUCTURE is used to compute offsets into each of the
|
|
|
27 tuple structures that contain operands. Since vector operands
|
|
|
28 are at different offsets depending on the particular structure
|
|
|
29 used, these offsets are computed at compile time for efficient
|
|
|
30 lookup at runtime. See gimple_ops().
|
|
|
31
|
|
|
32 If a code does not use operand vectors, STRUCTURE should be NULL. */
|
|
|
33
|
|
|
34 /* Error marker. This is used in similar ways as ERROR_MARK in tree.def. */
|
|
|
35 DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", NULL)
|
|
|
36
|
|
|
37 /* IMPORTANT. Do not rearrange the codes between GIMPLE_COND and
|
|
|
38 GIMPLE_RETURN. The ordering is exposed by gimple_has_ops calls.
|
|
|
39 These are all the GIMPLE statements with register operands. */
|
|
|
40
|
|
|
41 /* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL>
|
|
|
42 represents the conditional jump:
|
|
|
43
|
|
|
44 if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL
|
|
|
45
|
|
|
46 COND_CODE is the tree code used as the comparison predicate. It
|
|
|
47 must be of class tcc_comparison.
|
|
|
48
|
|
|
49 OP1 and OP2 are the operands used in the comparison. They must be
|
|
|
50 accepted by is_gimple_operand.
|
|
|
51
|
|
|
52 TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the
|
|
|
53 jump target for the comparison. */
|
|
|
54 DEFGSCODE(GIMPLE_COND, "gimple_cond", struct gimple_statement_with_ops)
|
|
|
55
|
|
|
56 /* GIMPLE_GOTO <TARGET> represents unconditional jumps.
|
|
|
57 TARGET is a LABEL_DECL or an expression node for computed GOTOs. */
|
|
|
58 DEFGSCODE(GIMPLE_GOTO, "gimple_goto", struct gimple_statement_with_ops)
|
|
|
59
|
|
|
60 /* GIMPLE_LABEL <LABEL> represents label statements. LABEL is a
|
|
|
61 LABEL_DECL representing a jump target. */
|
|
|
62 DEFGSCODE(GIMPLE_LABEL, "gimple_label", struct gimple_statement_with_ops)
|
|
|
63
|
|
|
64 /* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the
|
|
|
65 multiway branch:
|
|
|
66
|
|
|
67 switch (INDEX)
|
|
|
68 {
|
|
|
69 case LAB1: ...; break;
|
|
|
70 ...
|
|
|
71 case LABN: ...; break;
|
|
|
72 default: ...
|
|
|
73 }
|
|
|
74
|
|
|
75 INDEX is the variable evaluated to decide which label to jump to.
|
|
|
76
|
|
|
77 DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels.
|
|
|
78 They must be CASE_LABEL_EXPR nodes. */
|
|
|
79 DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", struct gimple_statement_with_ops)
|
|
|
80
|
|
|
81 /* GIMPLE_CHANGE_DYNAMIC_TYPE indicates a change in the dynamic type
|
|
|
82 of a memory location. This has no value and generates no
|
|
|
83 executable code. It is only used for type based alias analysis.
|
|
|
84 This is generated by C++ placement new and it's a direct
|
|
|
85 translation from CHANGE_DYNAMIC_TYPE_EXPR. The first operand
|
|
|
86 (gimple_cdt_new_type) is the new type. The second operand
|
|
|
87 (gimple_cdt_location) is the location (pointer) whose type is being
|
|
|
88 changed. */
|
|
|
89 DEFGSCODE(GIMPLE_CHANGE_DYNAMIC_TYPE, "gimple_change_dynamic_type",
|
|
|
90 struct gimple_statement_with_ops)
|
|
|
91
|
|
|
92 /* IMPORTANT.
|
|
|
93
|
|
|
94 Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN.
|
|
|
95 It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE
|
|
|
96 statements with memory and register operands. */
|
|
|
97
|
|
|
98 /* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment
|
|
|
99 statement
|
|
|
100
|
|
|
101 LHS = RHS1 SUBCODE RHS2.
|
|
|
102
|
|
|
103 SUBCODE is the tree code for the expression computed by the RHS of the
|
|
|
104 assignment. It must be one of the tree codes accepted by
|
|
|
105 get_gimple_rhs_class.
|
|
|
106
|
|
|
107 LHS is the operand on the LHS of the assignment. It must be a tree node
|
|
|
108 accepted by is_gimple_operand.
|
|
|
109
|
|
|
110 RHS1 is the first operand on the RHS of the assignment. It must be a tree
|
|
|
111 node accepted by is_gimple_operand.
|
|
|
112
|
|
|
113 RHS2 is the second operand on the RHS of the assignemnt. It must be a tree
|
|
|
114 node accepted by is_gimple_operand. This argument exists only if SUBCODE is
|
|
|
115 of class GIMPLE_BINARY_RHS. */
|
|
|
116 DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign",
|
|
|
117 struct gimple_statement_with_memory_ops)
|
|
|
118
|
|
|
119 /* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP>
|
|
|
120 represents inline assembly statements.
|
|
|
121
|
|
|
122 STRING is the string containing the assembly statements.
|
|
|
123 I1 ... IN are the N input operands.
|
|
|
124 O1 ... OM are the M output operands.
|
|
|
125 C1 ... CP are the P clobber operands. */
|
|
|
126 DEFGSCODE(GIMPLE_ASM, "gimple_asm", struct gimple_statement_asm)
|
|
|
127
|
|
|
128 /* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
|
|
|
129 calls.
|
|
|
130
|
|
|
131 FN is the callee. It must be accepted by is_gimple_call_addr.
|
|
|
132
|
|
|
133 LHS is the operand where the return value from FN is stored. It may
|
|
|
134 be NULL.
|
|
|
135
|
|
|
136 ARG1 ... ARGN are the arguments. They must all be accepted by
|
|
|
137 is_gimple_operand.
|
|
|
138
|
|
|
139 CHAIN is the optional static chain link for nested functions. */
|
|
|
140 DEFGSCODE(GIMPLE_CALL, "gimple_call",
|
|
|
141 struct gimple_statement_with_memory_ops)
|
|
|
142
|
|
|
143 /* GIMPLE_RETURN <RETVAL> represents return statements.
|
|
|
144
|
|
|
145 RETVAL is the value to return or NULL. If a value is returned it
|
|
|
146 must be accepted by is_gimple_operand. */
|
|
|
147 DEFGSCODE(GIMPLE_RETURN, "gimple_return",
|
|
|
148 struct gimple_statement_with_memory_ops)
|
|
|
149
|
|
|
150 /* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope.
|
|
|
151 VARS is the set of variables declared in that scope.
|
|
|
152 BLOCK is the symbol binding block used for debug information.
|
|
|
153 BODY is the sequence of statements in the scope. */
|
|
|
154 DEFGSCODE(GIMPLE_BIND, "gimple_bind", NULL)
|
|
|
155
|
|
|
156 /* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler.
|
|
|
157 TYPES is the type (or list of types) handled. HANDLER is the
|
|
|
158 sequence of statements that handle these types. */
|
|
|
159 DEFGSCODE(GIMPLE_CATCH, "gimple_catch", NULL)
|
|
|
160
|
|
|
161 /* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception
|
|
|
162 specification. TYPES is a list of allowed types and FAILURE is the
|
|
|
163 sequence of statements to execute on failure. */
|
|
|
164 DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", NULL)
|
|
|
165
|
|
|
166 /* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node
|
|
|
167
|
|
|
168 RESULT = PHI <ARG1, ..., ARGN>
|
|
|
169
|
|
|
170 RESULT is the SSA name created by this PHI node.
|
|
|
171
|
|
|
172 ARG1 ... ARGN are the arguments to the PHI node. N must be
|
|
|
173 exactly the same as the number of incoming edges to the basic block
|
|
|
174 holding the PHI node. Every argument is either an SSA name or a
|
|
|
175 tree node of class tcc_constant. */
|
|
|
176 DEFGSCODE(GIMPLE_PHI, "gimple_phi", NULL)
|
|
|
177
|
|
|
178 /* GIMPLE_RESX <REGION> resumes execution after an exception.
|
|
|
179 REGION is the region number being left. */
|
|
|
180 DEFGSCODE(GIMPLE_RESX, "gimple_resx", NULL)
|
|
|
181
|
|
|
182 /* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
|
|
|
183 represents a try/catch or a try/finally statement.
|
|
|
184
|
|
|
185 TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.
|
|
|
186
|
|
|
187 EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.
|
|
|
188
|
|
|
189 CLEANUP is the sequence of statements to execute according to
|
|
|
190 TRY_KIND. If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected
|
|
|
191 if an exception is thrown during execution of EVAL. If TRY_KIND is
|
|
|
192 GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
|
|
|
193 (regardless of whether EVAL finished normally, or jumped out or an
|
|
|
194 exception was thrown). */
|
|
|
195 DEFGSCODE(GIMPLE_TRY, "gimple_try", NULL)
|
|
|
196
|
|
|
197 /* GIMPLE_NOP represents the "do nothing" statement. */
|
|
|
198 DEFGSCODE(GIMPLE_NOP, "gimple_nop", NULL)
|
|
|
199
|
|
|
200
|
|
|
201 /* IMPORTANT.
|
|
|
202
|
|
|
203 Do not rearrange any of the GIMPLE_OMP_* codes. This ordering is
|
|
|
204 exposed by the range check in gimple_omp_subcode(). */
|
|
|
205
|
|
|
206
|
|
|
207 /* Tuples used for lowering of OMP_ATOMIC. Although the form of the OMP_ATOMIC
|
|
|
208 expression is very simple (just in form mem op= expr), various implicit
|
|
|
209 conversions may cause the expression to become more complex, so that it does
|
|
|
210 not fit the gimple grammar very well. To overcome this problem, OMP_ATOMIC
|
|
|
211 is rewritten as a sequence of two codes in gimplification:
|
|
|
212
|
|
|
213 GIMPLE_OMP_LOAD (tmp, mem)
|
|
|
214 val = some computations involving tmp;
|
|
|
215 GIMPLE_OMP_STORE (val). */
|
|
|
216 DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load", NULL)
|
|
|
217 DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store", NULL)
|
|
|
218
|
|
|
219 /* GIMPLE_OMP_CONTINUE marks the location of the loop or sections
|
|
|
220 iteration in partially lowered OpenMP code. */
|
|
|
221 DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", NULL)
|
|
|
222
|
|
|
223 /* GIMPLE_OMP_CRITICAL <NAME, BODY> represents
|
|
|
224
|
|
|
225 #pragma omp critical [name]
|
|
|
226
|
|
|
227 NAME is the name given to the critical section.
|
|
|
228 BODY is the sequence of statements that are inside the critical section. */
|
|
|
229 DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", NULL)
|
|
|
230
|
|
|
231 /* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY>
|
|
|
232 represents
|
|
|
233
|
|
|
234 PRE_BODY
|
|
|
235 #pragma omp for [clause1 ... clauseN]
|
|
|
236 for (INDEX = INITIAL; INDEX COND FINAL; INDEX {+=,-=} INCR)
|
|
|
237 BODY
|
|
|
238
|
|
|
239 BODY is the loop body.
|
|
|
240
|
|
|
241 CLAUSES is the list of clauses.
|
|
|
242
|
|
|
243 INDEX must be an integer or pointer variable, which is implicitly thread
|
|
|
244 private. It must be accepted by is_gimple_operand.
|
|
|
245
|
|
|
246 INITIAL is the initial value given to INDEX. It must be
|
|
|
247 accepted by is_gimple_operand.
|
|
|
248
|
|
|
249 FINAL is the final value that INDEX should take. It must
|
|
|
250 be accepted by is_gimple_operand.
|
|
|
251
|
|
|
252 COND is the condition code for the controlling predicate. It must
|
|
|
253 be one of { <, >, <=, >= }
|
|
|
254
|
|
|
255 INCR is the loop index increment. It must be tree node of type
|
|
|
256 tcc_constant.
|
|
|
257
|
|
|
258 PRE_BODY is a landing pad filled by the gimplifier with things from
|
|
|
259 INIT, COND, and INCR that are technically part of the OMP_FOR
|
|
|
260 structured block, but are evaluated before the loop body begins.
|
|
|
261
|
|
|
262 INITIAL, FINAL and INCR are required to be loop invariant integer
|
|
|
263 expressions that are evaluated without any synchronization.
|
|
|
264 The evaluation order, frequency of evaluation and side-effects are
|
|
|
265 unspecified by the standard. */
|
|
|
266 DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", NULL)
|
|
|
267
|
|
|
268 /* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master.
|
|
|
269 BODY is the sequence of statements to execute in the master section. */
|
|
|
270 DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", NULL)
|
|
|
271
|
|
|
272 /* GIMPLE_OMP_ORDERED <BODY> represents #pragma omp ordered.
|
|
|
273 BODY is the sequence of statements to execute in the ordered section. */
|
|
|
274 DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", NULL)
|
|
|
275
|
|
|
276 /* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents
|
|
|
277
|
|
|
278 #pragma omp parallel [CLAUSES]
|
|
|
279 BODY
|
|
|
280
|
|
|
281 BODY is a the sequence of statements to be executed by all threads.
|
|
|
282
|
|
|
283 CLAUSES is a TREE_LIST node with all the clauses.
|
|
|
284
|
|
|
285 CHILD_FN is set when outlining the body of the parallel region.
|
|
|
286 All the statements in BODY are moved into this newly created
|
|
|
287 function when converting OMP constructs into low-GIMPLE.
|
|
|
288
|
|
|
289 DATA_ARG is a local variable in the parent function containing data
|
|
|
290 to be shared with CHILD_FN. This is used to implement all the data
|
|
|
291 sharing clauses. */
|
|
|
292 DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", NULL)
|
|
|
293
|
|
|
294 /* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN,
|
|
|
295 ARG_SIZE, ARG_ALIGN> represents
|
|
|
296
|
|
|
297 #pragma omp task [CLAUSES]
|
|
|
298 BODY
|
|
|
299
|
|
|
300 BODY is a the sequence of statements to be executed by all threads.
|
|
|
301
|
|
|
302 CLAUSES is a TREE_LIST node with all the clauses.
|
|
|
303
|
|
|
304 CHILD_FN is set when outlining the body of the explicit task region.
|
|
|
305 All the statements in BODY are moved into this newly created
|
|
|
306 function when converting OMP constructs into low-GIMPLE.
|
|
|
307
|
|
|
308 DATA_ARG is a local variable in the parent function containing data
|
|
|
309 to be shared with CHILD_FN. This is used to implement all the data
|
|
|
310 sharing clauses.
|
|
|
311
|
|
|
312 COPY_FN is set when outlining the firstprivate var initialization.
|
|
|
313 All the needed statements are emitted into the newly created
|
|
|
314 function, or when only memcpy is needed, it is NULL.
|
|
|
315
|
|
|
316 ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming
|
|
|
317 data area allocated by GOMP_task and passed to CHILD_FN. */
|
|
|
318 DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", NULL)
|
|
|
319
|
|
|
320 /* OMP_RETURN marks the end of an OpenMP directive. */
|
|
|
321 DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", NULL)
|
|
|
322
|
|
|
323 /* OMP_SECTION <BODY> represents #pragma omp section.
|
|
|
324 BODY is the sequence of statements in the section body. */
|
|
|
325 DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", NULL)
|
|
|
326
|
|
|
327 /* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections.
|
|
|
328
|
|
|
329 BODY is the sequence of statements in the sections body.
|
|
|
330 CLAUSES is a TREE_LIST node holding the list of associated clauses.
|
|
|
331 CONTROL is a VAR_DECL used for deciding which of the sections
|
|
|
332 to execute. */
|
|
|
333 DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", NULL)
|
|
|
334
|
|
|
335 /* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after
|
|
|
336 OMP_SECTIONS. It represents the GIMPLE_SWITCH used to decide which
|
|
|
337 branch is taken. */
|
|
|
338 DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", NULL)
|
|
|
339
|
|
|
340 /* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single
|
|
|
341 BODY is the sequence of statements inside the single section.
|
|
|
342 CLAUSES is a TREE_LIST node holding the associated clauses. */
|
|
|
343 DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", NULL)
|
|
|
344
|
|
|
345 /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction.
|
|
|
346
|
|
|
347 PREDICT is one of the predictors from predict.def.
|
|
|
348
|
|
|
349 OUTCOME is NOT_TAKEN or TAKEN. */
|
|
|
350 DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", NULL)
|
|
|
351
|
|
|
352 /* This node represents a cleanup expression. It is ONLY USED INTERNALLY
|
|
|
353 by the gimplifier as a placeholder for cleanups, and its uses will be
|
|
|
354 cleaned up by the time gimplification is done.
|
|
|
355
|
|
|
356 This tuple should not exist outside of the gimplifier proper. */
|
|
|
357 DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", NULL)
|
