source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/tools/avr/lib/gcc/avr/4.9.2/plugin/include/gimple.def @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 2 years ago

Adding new version

File size: 15.3 KB
Line 
1/* This file contains the definitions of the GIMPLE IR tuples used in GCC.
2
3   Copyright (C) 2007-2014 Free Software Foundation, Inc.
4   Contributed by Aldy Hernandez <aldyh@redhat.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along 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, GSS_symbol).  */
24
25
26/* Error marker.  This is used in similar ways as ERROR_MARK in tree.def.  */
27DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE)
28
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.  */
32
33/* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL>
34   represents the conditional jump:
35
36   if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL
37
38   COND_CODE is the tree code used as the comparison predicate.  It
39   must be of class tcc_comparison.
40
41   OP1 and OP2 are the operands used in the comparison.  They must be
42   accepted by is_gimple_operand.
43
44   TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the
45   jump target for the comparison.  */
46DEFGSCODE(GIMPLE_COND, "gimple_cond", GSS_WITH_OPS)
47
48/* GIMPLE_DEBUG represents a debug statement.  */
49DEFGSCODE(GIMPLE_DEBUG, "gimple_debug", GSS_WITH_OPS)
50
51/* GIMPLE_GOTO <TARGET> represents unconditional jumps.
52   TARGET is a LABEL_DECL or an expression node for computed GOTOs.  */
53DEFGSCODE(GIMPLE_GOTO, "gimple_goto", GSS_WITH_OPS)
54
55/* GIMPLE_LABEL <LABEL> represents label statements.  LABEL is a
56   LABEL_DECL representing a jump target.  */
57DEFGSCODE(GIMPLE_LABEL, "gimple_label", GSS_WITH_OPS)
58
59/* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the
60   multiway branch:
61
62   switch (INDEX)
63   {
64     case LAB1: ...; break;
65     ...
66     case LABN: ...; break;
67     default: ...
68   }
69
70   INDEX is the variable evaluated to decide which label to jump to.
71
72   DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels.
73   They must be CASE_LABEL_EXPR nodes.  */
74DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", GSS_WITH_OPS)
75
76/* IMPORTANT.
77
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.  */
81
82/* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment
83   statement
84
85   LHS = RHS1 SUBCODE RHS2.
86
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.
91
92   LHS is the operand on the LHS of the assignment.  It must be a tree node
93   accepted by is_gimple_lvalue.
94
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.
97
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.  */
101DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign", GSS_WITH_MEM_OPS)
102
103/* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP>
104   represents inline assembly statements.
105
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.  */
111DEFGSCODE(GIMPLE_ASM, "gimple_asm", GSS_ASM)
112
113/* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
114   calls.
115
116   FN is the callee.  It must be accepted by is_gimple_call_addr.
117
118   LHS is the operand where the return value from FN is stored.  It may
119   be NULL.
120
121   ARG1 ... ARGN are the arguments.  They must all be accepted by
122   is_gimple_operand.
123
124    CHAIN is the optional static chain link for nested functions.  */
125DEFGSCODE(GIMPLE_CALL, "gimple_call", GSS_CALL)
126
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.  */
133DEFGSCODE(GIMPLE_TRANSACTION, "gimple_transaction", GSS_TRANSACTION)
134
135/* GIMPLE_RETURN <RETVAL> represents return statements.
136
137   RETVAL is the value to return or NULL.  If a value is returned it
138   must be accepted by is_gimple_operand.  */
139DEFGSCODE(GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS)
140
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.  */
145DEFGSCODE(GIMPLE_BIND, "gimple_bind", GSS_BIND)
146
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.  */
150DEFGSCODE(GIMPLE_CATCH, "gimple_catch", GSS_CATCH)
151
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.  */
155DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER)
156
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.  */
160DEFGSCODE(GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT)
161
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.  */
166DEFGSCODE(GIMPLE_EH_ELSE, "gimple_eh_else", GSS_EH_ELSE)
167
168/* GIMPLE_RESX resumes execution after an exception.  */
169DEFGSCODE(GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL)
170
171/* GIMPLE_EH_DISPATCH demultiplexes an exception edge based on
172   the FILTER argument.  */
173DEFGSCODE(GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL)
174
175/* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node
176
177   RESULT = PHI <ARG1, ..., ARGN>
178
179   RESULT is the SSA name created by this PHI node.
180
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.  */
185DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI)
186
187/* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
188   represents a try/catch or a try/finally statement.
189
190   TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.
191
192   EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.
193
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).  */
200DEFGSCODE(GIMPLE_TRY, "gimple_try", GSS_TRY)
201
202/* GIMPLE_NOP represents the "do nothing" statement.  */
203DEFGSCODE(GIMPLE_NOP, "gimple_nop", GSS_BASE)
204
205
206/* IMPORTANT.
207
208   Do not rearrange any of the GIMPLE_OMP_* codes.  This ordering is
209   exposed by the range check in gimple_omp_subcode().  */
210
211
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:
217
218   GIMPLE_OMP_LOAD (tmp, mem)
219   val = some computations involving tmp;
220   GIMPLE_OMP_STORE (val).  */
221DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load",
222          GSS_OMP_ATOMIC_LOAD)
223DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store",
224          GSS_OMP_ATOMIC_STORE_LAYOUT)
225
226/* GIMPLE_OMP_CONTINUE marks the location of the loop or sections
227   iteration in partially lowered OpenMP code.  */
228DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE)
229
230/* GIMPLE_OMP_CRITICAL <NAME, BODY> represents
231
232   #pragma omp critical [name]
233
234   NAME is the name given to the critical section.
235   BODY is the sequence of statements that are inside the critical section.  */
236DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL)
237
238/* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY>
239   represents
240
241   PRE_BODY
242   #pragma omp for [clause1 ... clauseN]
243   for (INDEX = INITIAL; INDEX COND FINAL; INDEX {+=,-=} INCR)
244   BODY
245
246   BODY is the loop body.
247
248   CLAUSES is the list of clauses.
249
250   INDEX must be an integer or pointer variable, which is implicitly thread
251   private.  It must be accepted by is_gimple_operand.
252
253   INITIAL is the initial value given to INDEX. It must be
254   accepted by is_gimple_operand.
255
256   FINAL is the final value that INDEX should take. It must
257   be accepted by is_gimple_operand.
258
259   COND is the condition code for the controlling predicate.  It must
260   be one of { <, >, <=, >= }
261
262   INCR is the loop index increment.  It must be tree node of type
263   tcc_constant.
264
265   PRE_BODY is a landing pad filled by the gimplifier with things from
266   INIT, COND, and INCR that are technically part of the OMP_FOR
267   structured block, but are evaluated before the loop body begins.
268
269   INITIAL, FINAL and INCR are required to be loop invariant integer
270   expressions that are evaluated without any synchronization.
271   The evaluation order, frequency of evaluation and side-effects are
272   unspecified by the standard.  */
273DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR)
274
275/* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master.
276   BODY is the sequence of statements to execute in the master section.  */
277DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP)
278
279/* GIMPLE_OMP_TASKGROUP <BODY> represents #pragma omp taskgroup.
280   BODY is the sequence of statements to execute in the taskgroup section.  */
281DEFGSCODE(GIMPLE_OMP_TASKGROUP, "gimple_omp_taskgroup", GSS_OMP)
282
283/* GIMPLE_OMP_ORDERED <BODY> represents #pragma omp ordered.
284   BODY is the sequence of statements to execute in the ordered section.  */
285DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP)
286
287/* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents
288
289   #pragma omp parallel [CLAUSES]
290   BODY
291
292   BODY is a the sequence of statements to be executed by all threads.
293
294   CLAUSES is an OMP_CLAUSE chain with all the clauses.
295
296   CHILD_FN is set when outlining the body of the parallel region.
297   All the statements in BODY are moved into this newly created
298   function when converting OMP constructs into low-GIMPLE.
299
300   DATA_ARG is a local variable in the parent function containing data
301   to be shared with CHILD_FN.  This is used to implement all the data
302   sharing clauses.  */
303DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL_LAYOUT)
304
305/* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN,
306                    ARG_SIZE, ARG_ALIGN> represents
307
308   #pragma omp task [CLAUSES]
309   BODY
310
311   BODY is a the sequence of statements to be executed by all threads.
312
313   CLAUSES is an OMP_CLAUSE chain with all the clauses.
314
315   CHILD_FN is set when outlining the body of the explicit task region.
316   All the statements in BODY are moved into this newly created
317   function when converting OMP constructs into low-GIMPLE.
318
319   DATA_ARG is a local variable in the parent function containing data
320   to be shared with CHILD_FN.  This is used to implement all the data
321   sharing clauses.
322
323   COPY_FN is set when outlining the firstprivate var initialization.
324   All the needed statements are emitted into the newly created
325   function, or when only memcpy is needed, it is NULL.
326
327   ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming
328   data area allocated by GOMP_task and passed to CHILD_FN.  */
329DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK)
330
331/* OMP_RETURN marks the end of an OpenMP directive.  */
332DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_OMP_ATOMIC_STORE_LAYOUT)
333
334/* OMP_SECTION <BODY> represents #pragma omp section.
335   BODY is the sequence of statements in the section body.  */
336DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP)
337
338/* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections.
339
340   BODY is the sequence of statements in the sections body.
341   CLAUSES is an OMP_CLAUSE chain holding the list of associated clauses.
342   CONTROL is a VAR_DECL used for deciding which of the sections
343   to execute.  */
344DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS)
345
346/* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after
347   OMP_SECTIONS.  It represents the GIMPLE_SWITCH used to decide which
348   branch is taken.  */
349DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE)
350
351/* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single
352   BODY is the sequence of statements inside the single section.
353   CLAUSES is an OMP_CLAUSE chain holding the associated clauses.  */
354DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE_LAYOUT)
355
356/* GIMPLE_OMP_TARGET <BODY, CLAUSES, CHILD_FN> represents
357   #pragma omp target {,data,update}
358   BODY is the sequence of statements inside the target construct
359   (NULL for target update).
360   CLAUSES is an OMP_CLAUSE chain holding the associated clauses.
361   CHILD_FN is set when outlining the body of the target 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.  */
367DEFGSCODE(GIMPLE_OMP_TARGET, "gimple_omp_target", GSS_OMP_PARALLEL_LAYOUT)
368
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.  */
372DEFGSCODE(GIMPLE_OMP_TEAMS, "gimple_omp_teams", GSS_OMP_SINGLE_LAYOUT)
373
374/* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction.
375
376   PREDICT is one of the predictors from predict.def.
377
378   OUTCOME is NOT_TAKEN or TAKEN.  */
379DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", GSS_BASE)
380
381/*  This node represents a cleanup expression.  It is ONLY USED INTERNALLY
382    by the gimplifier as a placeholder for cleanups, and its uses will be
383    cleaned up by the time gimplification is done.
384
385    This tuple should not exist outside of the gimplifier proper.  */
386DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE)
Note: See TracBrowser for help on using the repository browser.