Mercurial > hg > CbC > CbC_gcc
annotate gcc/c-omp.c @ 55:77e2b8dfacca gcc-4.4.5
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 |
rev | line source |
---|---|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1 /* This file contains routines to construct GNU OpenMP constructs, |
0 | 2 called from parsing in the C and C++ front ends. |
3 | |
4 Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc. | |
5 Contributed by Richard Henderson <rth@redhat.com>, | |
6 Diego Novillo <dnovillo@redhat.com>. | |
7 | |
8 This file is part of GCC. | |
9 | |
10 GCC is free software; you can redistribute it and/or modify it under | |
11 the terms of the GNU General Public License as published by the Free | |
12 Software Foundation; either version 3, or (at your option) any later | |
13 version. | |
14 | |
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
18 for more details. | |
19 | |
20 You should have received a copy of the GNU General Public License | |
21 along with GCC; see the file COPYING3. If not see | |
22 <http://www.gnu.org/licenses/>. */ | |
23 | |
24 #include "config.h" | |
25 #include "system.h" | |
26 #include "coretypes.h" | |
27 #include "tm.h" | |
28 #include "tree.h" | |
29 #include "function.h" | |
30 #include "c-common.h" | |
31 #include "toplev.h" | |
32 #include "gimple.h" | |
33 #include "bitmap.h" | |
34 #include "langhooks.h" | |
35 | |
36 | |
37 /* Complete a #pragma omp master construct. STMT is the structured-block | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
38 that follows the pragma. LOC is the l*/ |
0 | 39 |
40 tree | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
41 c_finish_omp_master (location_t loc, tree stmt) |
0 | 42 { |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
43 tree t = add_stmt (build1 (OMP_MASTER, void_type_node, stmt)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
44 SET_EXPR_LOCATION (t, loc); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
45 return t; |
0 | 46 } |
47 | |
48 /* Complete a #pragma omp critical construct. STMT is the structured-block | |
49 that follows the pragma, NAME is the identifier in the pragma, or null | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
50 if it was omitted. LOC is the location of the #pragma. */ |
0 | 51 |
52 tree | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
53 c_finish_omp_critical (location_t loc, tree body, tree name) |
0 | 54 { |
55 tree stmt = make_node (OMP_CRITICAL); | |
56 TREE_TYPE (stmt) = void_type_node; | |
57 OMP_CRITICAL_BODY (stmt) = body; | |
58 OMP_CRITICAL_NAME (stmt) = name; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
59 SET_EXPR_LOCATION (stmt, loc); |
0 | 60 return add_stmt (stmt); |
61 } | |
62 | |
63 /* Complete a #pragma omp ordered construct. STMT is the structured-block | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
64 that follows the pragma. LOC is the location of the #pragma. */ |
0 | 65 |
66 tree | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
67 c_finish_omp_ordered (location_t loc, tree stmt) |
0 | 68 { |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
69 tree t = build1 (OMP_ORDERED, void_type_node, stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
70 SET_EXPR_LOCATION (t, loc); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
71 return add_stmt (t); |
0 | 72 } |
73 | |
74 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
75 /* Complete a #pragma omp barrier construct. LOC is the location of |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
76 the #pragma. */ |
0 | 77 |
78 void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
79 c_finish_omp_barrier (location_t loc) |
0 | 80 { |
81 tree x; | |
82 | |
83 x = built_in_decls[BUILT_IN_GOMP_BARRIER]; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
84 x = build_call_expr_loc (loc, x, 0); |
0 | 85 add_stmt (x); |
86 } | |
87 | |
88 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
89 /* Complete a #pragma omp taskwait construct. LOC is the location of the |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
90 pragma. */ |
0 | 91 |
92 void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
93 c_finish_omp_taskwait (location_t loc) |
0 | 94 { |
95 tree x; | |
96 | |
97 x = built_in_decls[BUILT_IN_GOMP_TASKWAIT]; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
98 x = build_call_expr_loc (loc, x, 0); |
0 | 99 add_stmt (x); |
100 } | |
101 | |
102 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
103 /* Complete a #pragma omp atomic construct. The expression to be |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
104 implemented atomically is LHS code= RHS. LOC is the location of |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
105 the atomic statement. The value returned is either error_mark_node |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
106 (if the construct was erroneous) or an OMP_ATOMIC node which should |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
107 be added to the current statement tree with add_stmt.*/ |
0 | 108 |
109 tree | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
110 c_finish_omp_atomic (location_t loc, enum tree_code code, tree lhs, tree rhs) |
0 | 111 { |
112 tree x, type, addr; | |
113 | |
114 if (lhs == error_mark_node || rhs == error_mark_node) | |
115 return error_mark_node; | |
116 | |
117 /* ??? According to one reading of the OpenMP spec, complex type are | |
118 supported, but there are no atomic stores for any architecture. | |
119 But at least icc 9.0 doesn't support complex types here either. | |
120 And lets not even talk about vector types... */ | |
121 type = TREE_TYPE (lhs); | |
122 if (!INTEGRAL_TYPE_P (type) | |
123 && !POINTER_TYPE_P (type) | |
124 && !SCALAR_FLOAT_TYPE_P (type)) | |
125 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
126 error_at (loc, "invalid expression type for %<#pragma omp atomic%>"); |
0 | 127 return error_mark_node; |
128 } | |
129 | |
130 /* ??? Validate that rhs does not overlap lhs. */ | |
131 | |
132 /* Take and save the address of the lhs. From then on we'll reference it | |
133 via indirection. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
134 addr = build_unary_op (loc, ADDR_EXPR, lhs, 0); |
0 | 135 if (addr == error_mark_node) |
136 return error_mark_node; | |
137 addr = save_expr (addr); | |
138 if (TREE_CODE (addr) != SAVE_EXPR | |
139 && (TREE_CODE (addr) != ADDR_EXPR | |
140 || TREE_CODE (TREE_OPERAND (addr, 0)) != VAR_DECL)) | |
141 { | |
142 /* Make sure LHS is simple enough so that goa_lhs_expr_p can recognize | |
143 it even after unsharing function body. */ | |
144 tree var = create_tmp_var_raw (TREE_TYPE (addr), NULL); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
145 DECL_CONTEXT (var) = current_function_decl; |
0 | 146 addr = build4 (TARGET_EXPR, TREE_TYPE (addr), var, addr, NULL, NULL); |
147 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
148 lhs = build_indirect_ref (loc, addr, RO_NULL); |
0 | 149 |
150 /* There are lots of warnings, errors, and conversions that need to happen | |
151 in the course of interpreting a statement. Use the normal mechanisms | |
152 to do this, and then take it apart again. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
153 x = build_modify_expr (input_location, lhs, NULL_TREE, code, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
154 input_location, rhs, NULL_TREE); |
0 | 155 if (x == error_mark_node) |
156 return error_mark_node; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
157 gcc_assert (TREE_CODE (x) == MODIFY_EXPR); |
0 | 158 rhs = TREE_OPERAND (x, 1); |
159 | |
160 /* Punt the actual generation of atomic operations to common code. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
161 x = build2 (OMP_ATOMIC, void_type_node, addr, rhs); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
162 SET_EXPR_LOCATION (x, loc); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
163 return x; |
0 | 164 } |
165 | |
166 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
167 /* Complete a #pragma omp flush construct. We don't do anything with |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
168 the variable list that the syntax allows. LOC is the location of |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
169 the #pragma. */ |
0 | 170 |
171 void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
172 c_finish_omp_flush (location_t loc) |
0 | 173 { |
174 tree x; | |
175 | |
176 x = built_in_decls[BUILT_IN_SYNCHRONIZE]; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
177 x = build_call_expr_loc (loc, x, 0); |
0 | 178 add_stmt (x); |
179 } | |
180 | |
181 | |
182 /* Check and canonicalize #pragma omp for increment expression. | |
183 Helper function for c_finish_omp_for. */ | |
184 | |
185 static tree | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
186 check_omp_for_incr_expr (location_t loc, tree exp, tree decl) |
0 | 187 { |
188 tree t; | |
189 | |
190 if (!INTEGRAL_TYPE_P (TREE_TYPE (exp)) | |
191 || TYPE_PRECISION (TREE_TYPE (exp)) < TYPE_PRECISION (TREE_TYPE (decl))) | |
192 return error_mark_node; | |
193 | |
194 if (exp == decl) | |
195 return build_int_cst (TREE_TYPE (exp), 0); | |
196 | |
197 switch (TREE_CODE (exp)) | |
198 { | |
199 CASE_CONVERT: | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
200 t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl); |
0 | 201 if (t != error_mark_node) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
202 return fold_convert_loc (loc, TREE_TYPE (exp), t); |
0 | 203 break; |
204 case MINUS_EXPR: | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
205 t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl); |
0 | 206 if (t != error_mark_node) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
207 return fold_build2_loc (loc, MINUS_EXPR, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
208 TREE_TYPE (exp), t, TREE_OPERAND (exp, 1)); |
0 | 209 break; |
210 case PLUS_EXPR: | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
211 t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl); |
0 | 212 if (t != error_mark_node) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
213 return fold_build2_loc (loc, PLUS_EXPR, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
214 TREE_TYPE (exp), t, TREE_OPERAND (exp, 1)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
215 t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 1), decl); |
0 | 216 if (t != error_mark_node) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
217 return fold_build2_loc (loc, PLUS_EXPR, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
218 TREE_TYPE (exp), TREE_OPERAND (exp, 0), t); |
0 | 219 break; |
220 default: | |
221 break; | |
222 } | |
223 | |
224 return error_mark_node; | |
225 } | |
226 | |
227 /* Validate and emit code for the OpenMP directive #pragma omp for. | |
228 DECLV is a vector of iteration variables, for each collapsed loop. | |
229 INITV, CONDV and INCRV are vectors containing initialization | |
230 expressions, controlling predicates and increment expressions. | |
231 BODY is the body of the loop and PRE_BODY statements that go before | |
232 the loop. */ | |
233 | |
234 tree | |
235 c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv, | |
236 tree incrv, tree body, tree pre_body) | |
237 { | |
238 location_t elocus; | |
239 bool fail = false; | |
240 int i; | |
241 | |
242 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (initv)); | |
243 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (condv)); | |
244 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (incrv)); | |
245 for (i = 0; i < TREE_VEC_LENGTH (declv); i++) | |
246 { | |
247 tree decl = TREE_VEC_ELT (declv, i); | |
248 tree init = TREE_VEC_ELT (initv, i); | |
249 tree cond = TREE_VEC_ELT (condv, i); | |
250 tree incr = TREE_VEC_ELT (incrv, i); | |
251 | |
252 elocus = locus; | |
253 if (EXPR_HAS_LOCATION (init)) | |
254 elocus = EXPR_LOCATION (init); | |
255 | |
256 /* Validate the iteration variable. */ | |
257 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl)) | |
258 && TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE) | |
259 { | |
260 error_at (elocus, "invalid type for iteration variable %qE", decl); | |
261 fail = true; | |
262 } | |
263 | |
264 /* In the case of "for (int i = 0...)", init will be a decl. It should | |
265 have a DECL_INITIAL that we can turn into an assignment. */ | |
266 if (init == decl) | |
267 { | |
268 elocus = DECL_SOURCE_LOCATION (decl); | |
269 | |
270 init = DECL_INITIAL (decl); | |
271 if (init == NULL) | |
272 { | |
273 error_at (elocus, "%qE is not initialized", decl); | |
274 init = integer_zero_node; | |
275 fail = true; | |
276 } | |
277 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
278 init = build_modify_expr (elocus, decl, NULL_TREE, NOP_EXPR, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
279 /* FIXME diagnostics: This should |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
280 be the location of the INIT. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
281 elocus, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
282 init, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
283 NULL_TREE); |
0 | 284 } |
285 gcc_assert (TREE_CODE (init) == MODIFY_EXPR); | |
286 gcc_assert (TREE_OPERAND (init, 0) == decl); | |
287 | |
288 if (cond == NULL_TREE) | |
289 { | |
290 error_at (elocus, "missing controlling predicate"); | |
291 fail = true; | |
292 } | |
293 else | |
294 { | |
295 bool cond_ok = false; | |
296 | |
297 if (EXPR_HAS_LOCATION (cond)) | |
298 elocus = EXPR_LOCATION (cond); | |
299 | |
300 if (TREE_CODE (cond) == LT_EXPR | |
301 || TREE_CODE (cond) == LE_EXPR | |
302 || TREE_CODE (cond) == GT_EXPR | |
303 || TREE_CODE (cond) == GE_EXPR | |
304 || TREE_CODE (cond) == NE_EXPR) | |
305 { | |
306 tree op0 = TREE_OPERAND (cond, 0); | |
307 tree op1 = TREE_OPERAND (cond, 1); | |
308 | |
309 /* 2.5.1. The comparison in the condition is computed in | |
310 the type of DECL, otherwise the behavior is undefined. | |
311 | |
312 For example: | |
313 long n; int i; | |
314 i < n; | |
315 | |
316 according to ISO will be evaluated as: | |
317 (long)i < n; | |
318 | |
319 We want to force: | |
320 i < (int)n; */ | |
321 if (TREE_CODE (op0) == NOP_EXPR | |
322 && decl == TREE_OPERAND (op0, 0)) | |
323 { | |
324 TREE_OPERAND (cond, 0) = TREE_OPERAND (op0, 0); | |
325 TREE_OPERAND (cond, 1) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
326 = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl), |
0 | 327 TREE_OPERAND (cond, 1)); |
328 } | |
329 else if (TREE_CODE (op1) == NOP_EXPR | |
330 && decl == TREE_OPERAND (op1, 0)) | |
331 { | |
332 TREE_OPERAND (cond, 1) = TREE_OPERAND (op1, 0); | |
333 TREE_OPERAND (cond, 0) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
334 = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl), |
0 | 335 TREE_OPERAND (cond, 0)); |
336 } | |
337 | |
338 if (decl == TREE_OPERAND (cond, 0)) | |
339 cond_ok = true; | |
340 else if (decl == TREE_OPERAND (cond, 1)) | |
341 { | |
342 TREE_SET_CODE (cond, | |
343 swap_tree_comparison (TREE_CODE (cond))); | |
344 TREE_OPERAND (cond, 1) = TREE_OPERAND (cond, 0); | |
345 TREE_OPERAND (cond, 0) = decl; | |
346 cond_ok = true; | |
347 } | |
348 | |
349 if (TREE_CODE (cond) == NE_EXPR) | |
350 { | |
351 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl))) | |
352 cond_ok = false; | |
353 else if (operand_equal_p (TREE_OPERAND (cond, 1), | |
354 TYPE_MIN_VALUE (TREE_TYPE (decl)), | |
355 0)) | |
356 TREE_SET_CODE (cond, GT_EXPR); | |
357 else if (operand_equal_p (TREE_OPERAND (cond, 1), | |
358 TYPE_MAX_VALUE (TREE_TYPE (decl)), | |
359 0)) | |
360 TREE_SET_CODE (cond, LT_EXPR); | |
361 else | |
362 cond_ok = false; | |
363 } | |
364 } | |
365 | |
366 if (!cond_ok) | |
367 { | |
368 error_at (elocus, "invalid controlling predicate"); | |
369 fail = true; | |
370 } | |
371 } | |
372 | |
373 if (incr == NULL_TREE) | |
374 { | |
375 error_at (elocus, "missing increment expression"); | |
376 fail = true; | |
377 } | |
378 else | |
379 { | |
380 bool incr_ok = false; | |
381 | |
382 if (EXPR_HAS_LOCATION (incr)) | |
383 elocus = EXPR_LOCATION (incr); | |
384 | |
385 /* Check all the valid increment expressions: v++, v--, ++v, --v, | |
386 v = v + incr, v = incr + v and v = v - incr. */ | |
387 switch (TREE_CODE (incr)) | |
388 { | |
389 case POSTINCREMENT_EXPR: | |
390 case PREINCREMENT_EXPR: | |
391 case POSTDECREMENT_EXPR: | |
392 case PREDECREMENT_EXPR: | |
393 if (TREE_OPERAND (incr, 0) != decl) | |
394 break; | |
395 | |
396 incr_ok = true; | |
397 if (POINTER_TYPE_P (TREE_TYPE (decl)) | |
398 && TREE_OPERAND (incr, 1)) | |
399 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
400 tree t = fold_convert_loc (elocus, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
401 sizetype, TREE_OPERAND (incr, 1)); |
0 | 402 |
403 if (TREE_CODE (incr) == POSTDECREMENT_EXPR | |
404 || TREE_CODE (incr) == PREDECREMENT_EXPR) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
405 t = fold_build1_loc (elocus, NEGATE_EXPR, sizetype, t); |
0 | 406 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (decl), decl, t); |
407 incr = build2 (MODIFY_EXPR, void_type_node, decl, t); | |
408 } | |
409 break; | |
410 | |
411 case MODIFY_EXPR: | |
412 if (TREE_OPERAND (incr, 0) != decl) | |
413 break; | |
414 if (TREE_OPERAND (incr, 1) == decl) | |
415 break; | |
416 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR | |
417 && (TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == decl | |
418 || TREE_OPERAND (TREE_OPERAND (incr, 1), 1) == decl)) | |
419 incr_ok = true; | |
420 else if ((TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR | |
421 || (TREE_CODE (TREE_OPERAND (incr, 1)) | |
422 == POINTER_PLUS_EXPR)) | |
423 && TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == decl) | |
424 incr_ok = true; | |
425 else | |
426 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
427 tree t = check_omp_for_incr_expr (elocus, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
428 TREE_OPERAND (incr, 1), |
0 | 429 decl); |
430 if (t != error_mark_node) | |
431 { | |
432 incr_ok = true; | |
433 t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t); | |
434 incr = build2 (MODIFY_EXPR, void_type_node, decl, t); | |
435 } | |
436 } | |
437 break; | |
438 | |
439 default: | |
440 break; | |
441 } | |
442 if (!incr_ok) | |
443 { | |
444 error_at (elocus, "invalid increment expression"); | |
445 fail = true; | |
446 } | |
447 } | |
448 | |
449 TREE_VEC_ELT (initv, i) = init; | |
450 TREE_VEC_ELT (incrv, i) = incr; | |
451 } | |
452 | |
453 if (fail) | |
454 return NULL; | |
455 else | |
456 { | |
457 tree t = make_node (OMP_FOR); | |
458 | |
459 TREE_TYPE (t) = void_type_node; | |
460 OMP_FOR_INIT (t) = initv; | |
461 OMP_FOR_COND (t) = condv; | |
462 OMP_FOR_INCR (t) = incrv; | |
463 OMP_FOR_BODY (t) = body; | |
464 OMP_FOR_PRE_BODY (t) = pre_body; | |
465 | |
466 SET_EXPR_LOCATION (t, locus); | |
467 return add_stmt (t); | |
468 } | |
469 } | |
470 | |
471 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
472 /* Divide CLAUSES into two lists: those that apply to a parallel |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
473 construct, and those that apply to a work-sharing construct. Place |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
474 the results in *PAR_CLAUSES and *WS_CLAUSES respectively. In |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
475 addition, add a nowait clause to the work-sharing list. LOC is the |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
476 location of the OMP_PARALLEL*. */ |
0 | 477 |
478 void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
479 c_split_parallel_clauses (location_t loc, tree clauses, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
480 tree *par_clauses, tree *ws_clauses) |
0 | 481 { |
482 tree next; | |
483 | |
484 *par_clauses = NULL; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
485 *ws_clauses = build_omp_clause (loc, OMP_CLAUSE_NOWAIT); |
0 | 486 |
487 for (; clauses ; clauses = next) | |
488 { | |
489 next = OMP_CLAUSE_CHAIN (clauses); | |
490 | |
491 switch (OMP_CLAUSE_CODE (clauses)) | |
492 { | |
493 case OMP_CLAUSE_PRIVATE: | |
494 case OMP_CLAUSE_SHARED: | |
495 case OMP_CLAUSE_FIRSTPRIVATE: | |
496 case OMP_CLAUSE_LASTPRIVATE: | |
497 case OMP_CLAUSE_REDUCTION: | |
498 case OMP_CLAUSE_COPYIN: | |
499 case OMP_CLAUSE_IF: | |
500 case OMP_CLAUSE_NUM_THREADS: | |
501 case OMP_CLAUSE_DEFAULT: | |
502 OMP_CLAUSE_CHAIN (clauses) = *par_clauses; | |
503 *par_clauses = clauses; | |
504 break; | |
505 | |
506 case OMP_CLAUSE_SCHEDULE: | |
507 case OMP_CLAUSE_ORDERED: | |
508 case OMP_CLAUSE_COLLAPSE: | |
509 OMP_CLAUSE_CHAIN (clauses) = *ws_clauses; | |
510 *ws_clauses = clauses; | |
511 break; | |
512 | |
513 default: | |
514 gcc_unreachable (); | |
515 } | |
516 } | |
517 } | |
518 | |
519 /* True if OpenMP sharing attribute of DECL is predetermined. */ | |
520 | |
521 enum omp_clause_default_kind | |
522 c_omp_predetermined_sharing (tree decl) | |
523 { | |
524 /* Variables with const-qualified type having no mutable member | |
525 are predetermined shared. */ | |
526 if (TREE_READONLY (decl)) | |
527 return OMP_CLAUSE_DEFAULT_SHARED; | |
528 | |
529 return OMP_CLAUSE_DEFAULT_UNSPECIFIED; | |
530 } |