Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple.def @ 55:77e2b8dfacca gcc-4.4.5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update it from 4.4.3 to 4.5.0
author ryoma <e075725@ie.u-ryukyu.ac.jp>
date Fri, 12 Feb 2010 23:39:51 +0900
parents a06113de4d67
children b7f97abdc517
comparison
equal deleted inserted replaced
52:c156f1bd5cd9 55:77e2b8dfacca
1 /* This file contains the definitions of the GIMPLE IR tuples used in GCC. 1 /* This file contains the definitions of the GIMPLE IR tuples used in GCC.
2 2
3 Copyright (C) 2007, 2008 Free Software Foundation, Inc. 3 Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com> 4 Contributed by Aldy Hernandez <aldyh@redhat.com>
5 5
6 This file is part of GCC. 6 This file is part of GCC.
7 7
8 GCC is free software; you can redistribute it and/or modify it under 8 GCC is free software; you can redistribute it and/or modify it under
18 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see 19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */ 20 <http://www.gnu.org/licenses/>. */
21 21
22 /* The format of this file is 22 /* The format of this file is
23 DEFGSCODE(GIMPLE_symbol, printable name, structure). 23 DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol). */
24 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 25
34 /* Error marker. This is used in similar ways as ERROR_MARK in tree.def. */ 26 /* Error marker. This is used in similar ways as ERROR_MARK in tree.def. */
35 DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", NULL) 27 DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE)
36 28
37 /* IMPORTANT. Do not rearrange the codes between GIMPLE_COND and 29 /* IMPORTANT. Do not rearrange the codes between GIMPLE_COND and
38 GIMPLE_RETURN. The ordering is exposed by gimple_has_ops calls. 30 GIMPLE_RETURN. The ordering is exposed by gimple_has_ops calls.
39 These are all the GIMPLE statements with register operands. */ 31 These are all the GIMPLE statements with register operands. */
40 32
41 /* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL> 33 /* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL>
42 represents the conditional jump: 34 represents the conditional jump:
43 35
44 if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL 36 if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL
45 37
46 COND_CODE is the tree code used as the comparison predicate. It 38 COND_CODE is the tree code used as the comparison predicate. It
47 must be of class tcc_comparison. 39 must be of class tcc_comparison.
48 40
49 OP1 and OP2 are the operands used in the comparison. They must be 41 OP1 and OP2 are the operands used in the comparison. They must be
50 accepted by is_gimple_operand. 42 accepted by is_gimple_operand.
51 43
52 TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the 44 TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the
53 jump target for the comparison. */ 45 jump target for the comparison. */
54 DEFGSCODE(GIMPLE_COND, "gimple_cond", struct gimple_statement_with_ops) 46 DEFGSCODE(GIMPLE_COND, "gimple_cond", GSS_WITH_OPS)
47
48 /* GIMPLE_DEBUG represents a debug statement. */
49 DEFGSCODE(GIMPLE_DEBUG, "gimple_debug", GSS_WITH_OPS)
55 50
56 /* GIMPLE_GOTO <TARGET> represents unconditional jumps. 51 /* GIMPLE_GOTO <TARGET> represents unconditional jumps.
57 TARGET is a LABEL_DECL or an expression node for computed GOTOs. */ 52 TARGET is a LABEL_DECL or an expression node for computed GOTOs. */
58 DEFGSCODE(GIMPLE_GOTO, "gimple_goto", struct gimple_statement_with_ops) 53 DEFGSCODE(GIMPLE_GOTO, "gimple_goto", GSS_WITH_OPS)
59 54
60 /* GIMPLE_LABEL <LABEL> represents label statements. LABEL is a 55 /* GIMPLE_LABEL <LABEL> represents label statements. LABEL is a
61 LABEL_DECL representing a jump target. */ 56 LABEL_DECL representing a jump target. */
62 DEFGSCODE(GIMPLE_LABEL, "gimple_label", struct gimple_statement_with_ops) 57 DEFGSCODE(GIMPLE_LABEL, "gimple_label", GSS_WITH_OPS)
63 58
64 /* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the 59 /* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the
65 multiway branch: 60 multiway branch:
66 61
67 switch (INDEX) 62 switch (INDEX)
74 69
75 INDEX is the variable evaluated to decide which label to jump to. 70 INDEX is the variable evaluated to decide which label to jump to.
76 71
77 DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels. 72 DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels.
78 They must be CASE_LABEL_EXPR nodes. */ 73 They must be CASE_LABEL_EXPR nodes. */
79 DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", struct gimple_statement_with_ops) 74 DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", GSS_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 75
92 /* IMPORTANT. 76 /* IMPORTANT.
93 77
94 Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN. 78 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 79 It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE
96 statements with memory and register operands. */ 80 statements with memory and register operands. */
97 81
98 /* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment 82 /* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment
100 84
101 LHS = RHS1 SUBCODE RHS2. 85 LHS = RHS1 SUBCODE RHS2.
102 86
103 SUBCODE is the tree code for the expression computed by the RHS of the 87 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 88 assignment. It must be one of the tree codes accepted by
105 get_gimple_rhs_class. 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.
106 91
107 LHS is the operand on the LHS of the assignment. It must be a tree node 92 LHS is the operand on the LHS of the assignment. It must be a tree node
108 accepted by is_gimple_operand. 93 accepted by is_gimple_lvalue.
109 94
110 RHS1 is the first operand on the RHS of the assignment. It must be a tree 95 RHS1 is the first operand on the RHS of the assignment. It must always be
111 node accepted by is_gimple_operand. 96 present. It must be a tree node accepted by is_gimple_val.
112 97
113 RHS2 is the second operand on the RHS of the assignemnt. It must be a tree 98 RHS2 is the second operand on the RHS of the assignment. It must be a tree
114 node accepted by is_gimple_operand. This argument exists only if SUBCODE is 99 node accepted by is_gimple_val. This argument exists only if SUBCODE is
115 of class GIMPLE_BINARY_RHS. */ 100 of class GIMPLE_BINARY_RHS. */
116 DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign", 101 DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign", GSS_WITH_MEM_OPS)
117 struct gimple_statement_with_memory_ops)
118 102
119 /* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP> 103 /* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP>
120 represents inline assembly statements. 104 represents inline assembly statements.
121 105
122 STRING is the string containing the assembly statements. 106 STRING is the string containing the assembly statements.
123 I1 ... IN are the N input operands. 107 I1 ... IN are the N input operands.
124 O1 ... OM are the M output operands. 108 O1 ... OM are the M output operands.
125 C1 ... CP are the P clobber operands. */ 109 C1 ... CP are the P clobber operands.
126 DEFGSCODE(GIMPLE_ASM, "gimple_asm", struct gimple_statement_asm) 110 L1 ... LQ are the Q label operands. */
111 DEFGSCODE(GIMPLE_ASM, "gimple_asm", GSS_ASM)
127 112
128 /* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function 113 /* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
129 calls. 114 calls.
130 115
131 FN is the callee. It must be accepted by is_gimple_call_addr. 116 FN is the callee. It must be accepted by is_gimple_call_addr.
135 120
136 ARG1 ... ARGN are the arguments. They must all be accepted by 121 ARG1 ... ARGN are the arguments. They must all be accepted by
137 is_gimple_operand. 122 is_gimple_operand.
138 123
139 CHAIN is the optional static chain link for nested functions. */ 124 CHAIN is the optional static chain link for nested functions. */
140 DEFGSCODE(GIMPLE_CALL, "gimple_call", 125 DEFGSCODE(GIMPLE_CALL, "gimple_call", GSS_WITH_MEM_OPS)
141 struct gimple_statement_with_memory_ops)
142 126
143 /* GIMPLE_RETURN <RETVAL> represents return statements. 127 /* GIMPLE_RETURN <RETVAL> represents return statements.
144 128
145 RETVAL is the value to return or NULL. If a value is returned it 129 RETVAL is the value to return or NULL. If a value is returned it
146 must be accepted by is_gimple_operand. */ 130 must be accepted by is_gimple_operand. */
147 DEFGSCODE(GIMPLE_RETURN, "gimple_return", 131 DEFGSCODE(GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS)
148 struct gimple_statement_with_memory_ops)
149 132
150 /* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope. 133 /* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope.
151 VARS is the set of variables declared in that scope. 134 VARS is the set of variables declared in that scope.
152 BLOCK is the symbol binding block used for debug information. 135 BLOCK is the symbol binding block used for debug information.
153 BODY is the sequence of statements in the scope. */ 136 BODY is the sequence of statements in the scope. */
154 DEFGSCODE(GIMPLE_BIND, "gimple_bind", NULL) 137 DEFGSCODE(GIMPLE_BIND, "gimple_bind", GSS_BIND)
155 138
156 /* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler. 139 /* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler.
157 TYPES is the type (or list of types) handled. HANDLER is the 140 TYPES is the type (or list of types) handled. HANDLER is the
158 sequence of statements that handle these types. */ 141 sequence of statements that handle these types. */
159 DEFGSCODE(GIMPLE_CATCH, "gimple_catch", NULL) 142 DEFGSCODE(GIMPLE_CATCH, "gimple_catch", GSS_CATCH)
160 143
161 /* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception 144 /* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception
162 specification. TYPES is a list of allowed types and FAILURE is the 145 specification. TYPES is a list of allowed types and FAILURE is the
163 sequence of statements to execute on failure. */ 146 sequence of statements to execute on failure. */
164 DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", NULL) 147 DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER)
148
149 /* GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier.
150 DECL is a noreturn function decl taking no arguments that will
151 be invoked if an exception propagates to this point. */
152 DEFGSCODE(GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT)
153
154 /* GIMPLE_RESX resumes execution after an exception. */
155 DEFGSCODE(GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL)
156
157 /* GIMPLE_EH_DISPATCH demultiplexes an exception edge based on
158 the FILTER argument. */
159 DEFGSCODE(GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL)
165 160
166 /* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node 161 /* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node
167 162
168 RESULT = PHI <ARG1, ..., ARGN> 163 RESULT = PHI <ARG1, ..., ARGN>
169 164
171 166
172 ARG1 ... ARGN are the arguments to the PHI node. N must be 167 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 168 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 169 holding the PHI node. Every argument is either an SSA name or a
175 tree node of class tcc_constant. */ 170 tree node of class tcc_constant. */
176 DEFGSCODE(GIMPLE_PHI, "gimple_phi", NULL) 171 DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI)
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 172
182 /* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP> 173 /* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
183 represents a try/catch or a try/finally statement. 174 represents a try/catch or a try/finally statement.
184 175
185 TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. 176 TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.
190 TRY_KIND. If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected 181 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 182 if an exception is thrown during execution of EVAL. If TRY_KIND is
192 GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL 183 GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
193 (regardless of whether EVAL finished normally, or jumped out or an 184 (regardless of whether EVAL finished normally, or jumped out or an
194 exception was thrown). */ 185 exception was thrown). */
195 DEFGSCODE(GIMPLE_TRY, "gimple_try", NULL) 186 DEFGSCODE(GIMPLE_TRY, "gimple_try", GSS_TRY)
196 187
197 /* GIMPLE_NOP represents the "do nothing" statement. */ 188 /* GIMPLE_NOP represents the "do nothing" statement. */
198 DEFGSCODE(GIMPLE_NOP, "gimple_nop", NULL) 189 DEFGSCODE(GIMPLE_NOP, "gimple_nop", GSS_BASE)
199 190
200 191
201 /* IMPORTANT. 192 /* IMPORTANT.
202 193
203 Do not rearrange any of the GIMPLE_OMP_* codes. This ordering is 194 Do not rearrange any of the GIMPLE_OMP_* codes. This ordering is
204 exposed by the range check in gimple_omp_subcode(). */ 195 exposed by the range check in gimple_omp_subcode(). */
205 196
206 197
207 /* Tuples used for lowering of OMP_ATOMIC. Although the form of the OMP_ATOMIC 198 /* Tuples used for lowering of OMP_ATOMIC. Although the form of the OMP_ATOMIC
211 is rewritten as a sequence of two codes in gimplification: 202 is rewritten as a sequence of two codes in gimplification:
212 203
213 GIMPLE_OMP_LOAD (tmp, mem) 204 GIMPLE_OMP_LOAD (tmp, mem)
214 val = some computations involving tmp; 205 val = some computations involving tmp;
215 GIMPLE_OMP_STORE (val). */ 206 GIMPLE_OMP_STORE (val). */
216 DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load", NULL) 207 DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load",
217 DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store", NULL) 208 GSS_OMP_ATOMIC_LOAD)
209 DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store",
210 GSS_OMP_ATOMIC_STORE)
218 211
219 /* GIMPLE_OMP_CONTINUE marks the location of the loop or sections 212 /* GIMPLE_OMP_CONTINUE marks the location of the loop or sections
220 iteration in partially lowered OpenMP code. */ 213 iteration in partially lowered OpenMP code. */
221 DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", NULL) 214 DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE)
222 215
223 /* GIMPLE_OMP_CRITICAL <NAME, BODY> represents 216 /* GIMPLE_OMP_CRITICAL <NAME, BODY> represents
224 217
225 #pragma omp critical [name] 218 #pragma omp critical [name]
226 219
227 NAME is the name given to the critical section. 220 NAME is the name given to the critical section.
228 BODY is the sequence of statements that are inside the critical section. */ 221 BODY is the sequence of statements that are inside the critical section. */
229 DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", NULL) 222 DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL)
230 223
231 /* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY> 224 /* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY>
232 represents 225 represents
233 226
234 PRE_BODY 227 PRE_BODY
261 254
262 INITIAL, FINAL and INCR are required to be loop invariant integer 255 INITIAL, FINAL and INCR are required to be loop invariant integer
263 expressions that are evaluated without any synchronization. 256 expressions that are evaluated without any synchronization.
264 The evaluation order, frequency of evaluation and side-effects are 257 The evaluation order, frequency of evaluation and side-effects are
265 unspecified by the standard. */ 258 unspecified by the standard. */
266 DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", NULL) 259 DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR)
267 260
268 /* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master. 261 /* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master.
269 BODY is the sequence of statements to execute in the master section. */ 262 BODY is the sequence of statements to execute in the master section. */
270 DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", NULL) 263 DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP)
271 264
272 /* GIMPLE_OMP_ORDERED <BODY> represents #pragma omp ordered. 265 /* GIMPLE_OMP_ORDERED <BODY> represents #pragma omp ordered.
273 BODY is the sequence of statements to execute in the ordered section. */ 266 BODY is the sequence of statements to execute in the ordered section. */
274 DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", NULL) 267 DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP)
275 268
276 /* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents 269 /* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents
277 270
278 #pragma omp parallel [CLAUSES] 271 #pragma omp parallel [CLAUSES]
279 BODY 272 BODY
287 function when converting OMP constructs into low-GIMPLE. 280 function when converting OMP constructs into low-GIMPLE.
288 281
289 DATA_ARG is a local variable in the parent function containing data 282 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 283 to be shared with CHILD_FN. This is used to implement all the data
291 sharing clauses. */ 284 sharing clauses. */
292 DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", NULL) 285 DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL)
293 286
294 /* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN, 287 /* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN,
295 ARG_SIZE, ARG_ALIGN> represents 288 ARG_SIZE, ARG_ALIGN> represents
296 289
297 #pragma omp task [CLAUSES] 290 #pragma omp task [CLAUSES]
313 All the needed statements are emitted into the newly created 306 All the needed statements are emitted into the newly created
314 function, or when only memcpy is needed, it is NULL. 307 function, or when only memcpy is needed, it is NULL.
315 308
316 ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming 309 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. */ 310 data area allocated by GOMP_task and passed to CHILD_FN. */
318 DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", NULL) 311 DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK)
319 312
320 /* OMP_RETURN marks the end of an OpenMP directive. */ 313 /* OMP_RETURN marks the end of an OpenMP directive. */
321 DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", NULL) 314 DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_BASE)
322 315
323 /* OMP_SECTION <BODY> represents #pragma omp section. 316 /* OMP_SECTION <BODY> represents #pragma omp section.
324 BODY is the sequence of statements in the section body. */ 317 BODY is the sequence of statements in the section body. */
325 DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", NULL) 318 DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP)
326 319
327 /* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections. 320 /* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections.
328 321
329 BODY is the sequence of statements in the sections body. 322 BODY is the sequence of statements in the sections body.
330 CLAUSES is a TREE_LIST node holding the list of associated clauses. 323 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 324 CONTROL is a VAR_DECL used for deciding which of the sections
332 to execute. */ 325 to execute. */
333 DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", NULL) 326 DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS)
334 327
335 /* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after 328 /* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after
336 OMP_SECTIONS. It represents the GIMPLE_SWITCH used to decide which 329 OMP_SECTIONS. It represents the GIMPLE_SWITCH used to decide which
337 branch is taken. */ 330 branch is taken. */
338 DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", NULL) 331 DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE)
339 332
340 /* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single 333 /* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single
341 BODY is the sequence of statements inside the single section. 334 BODY is the sequence of statements inside the single section.
342 CLAUSES is a TREE_LIST node holding the associated clauses. */ 335 CLAUSES is a TREE_LIST node holding the associated clauses. */
343 DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", NULL) 336 DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE)
344 337
345 /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction. 338 /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction.
346 339
347 PREDICT is one of the predictors from predict.def. 340 PREDICT is one of the predictors from predict.def.
348 341
349 OUTCOME is NOT_TAKEN or TAKEN. */ 342 OUTCOME is NOT_TAKEN or TAKEN. */
350 DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", NULL) 343 DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", GSS_BASE)
351 344
352 /* This node represents a cleanup expression. It is ONLY USED INTERNALLY 345 /* 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 346 by the gimplifier as a placeholder for cleanups, and its uses will be
354 cleaned up by the time gimplification is done. 347 cleaned up by the time gimplification is done.
355 348
356 This tuple should not exist outside of the gimplifier proper. */ 349 This tuple should not exist outside of the gimplifier proper. */
357 DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", NULL) 350 DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE)