Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple.def @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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)