Mercurial > hg > CbC > CbC_gcc
comparison gcc/cilk-common.c @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 /* This file is part of the Intel(R) Cilk(TM) Plus support | |
2 This file contains the CilkPlus Intrinsics | |
3 Copyright (C) 2013-2017 Free Software Foundation, Inc. | |
4 Contributed by Balaji V. Iyer <balaji.v.iyer@intel.com>, | |
5 Intel Corporation | |
6 | |
7 This file is part of GCC. | |
8 | |
9 GCC is free software; you can redistribute it and/or modify it | |
10 under the terms of the GNU General Public License as published by | |
11 the Free Software Foundation; either version 3, or (at your option) | |
12 any later version. | |
13 | |
14 GCC is distributed in the hope that it will be useful, but | |
15 WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 General Public License for more details. | |
18 | |
19 You should have received a copy of the GNU General Public License | |
20 along with GCC; see the file COPYING3. If not see | |
21 <http://www.gnu.org/licenses/>. */ | |
22 | |
23 #include "config.h" | |
24 #include "system.h" | |
25 #include "coretypes.h" | |
26 #include "tm.h" | |
27 #include "function.h" | |
28 #include "rtl.h" | |
29 #include "tree.h" | |
30 #include "stringpool.h" | |
31 #include "expmed.h" | |
32 #include "optabs-query.h" | |
33 #include "insn-config.h" | |
34 #include "memmodel.h" | |
35 #include "emit-rtl.h" | |
36 #include "recog.h" | |
37 #include "fold-const.h" | |
38 #include "stor-layout.h" | |
39 #include "langhooks.h" | |
40 #include "explow.h" | |
41 #include "profile-count.h" | |
42 #include "expr.h" | |
43 #include "tree-iterator.h" | |
44 #include "gimplify.h" | |
45 #include "cilk.h" | |
46 | |
47 /* This structure holds all the important fields of the internal structures, | |
48 internal built-in functions, and Cilk-specific data types. Explanation of | |
49 all the these fielsd are given in cilk.h. */ | |
50 tree cilk_trees[(int) CILK_TI_MAX]; | |
51 | |
52 /* Returns the value in structure FRAME pointed by the FIELD_NUMBER | |
53 (e.g. X.y). | |
54 FIELD_NUMBER is an index to the structure FRAME_PTR. For details | |
55 about these fields, refer to cilk_trees structure in cilk.h and | |
56 cilk_init_builtins function in this file. Returns a TREE that is the type | |
57 of the field represented by FIELD_NUMBER. If VOLATIL parameter is set | |
58 to true then the returning field is set as volatile. */ | |
59 | |
60 tree | |
61 cilk_dot (tree frame, int field_number, bool volatil) | |
62 { | |
63 tree field = cilk_trees[field_number]; | |
64 field = fold_build3 (COMPONENT_REF, TREE_TYPE (field), frame, field, | |
65 NULL_TREE); | |
66 TREE_THIS_VOLATILE (field) = volatil; | |
67 return field; | |
68 } | |
69 | |
70 /* Returns the address of a field in FRAME_PTR, pointed by FIELD_NUMBER. | |
71 (e.g. (&X)->y). Please see cilk_dot function for explanation of the | |
72 FIELD_NUMBER. Returns a tree that is the type of the field represented | |
73 by FIELD_NUMBER. If VOLATIL parameter is set to true then the returning | |
74 field is set as volatile. */ | |
75 | |
76 tree | |
77 cilk_arrow (tree frame_ptr, int field_number, bool volatil) | |
78 { | |
79 return cilk_dot (build_simple_mem_ref (frame_ptr), | |
80 field_number, volatil); | |
81 } | |
82 | |
83 | |
84 /* This function will add FIELD of type TYPE to a defined built-in | |
85 structure. *NAME is the name of the field to be added. */ | |
86 | |
87 static tree | |
88 add_field (const char *name, tree type, tree fields) | |
89 { | |
90 tree t = get_identifier (name); | |
91 tree field = build_decl (BUILTINS_LOCATION, FIELD_DECL, t, type); | |
92 TREE_CHAIN (field) = fields; | |
93 return field; | |
94 } | |
95 | |
96 /* This function will define a built-in function of NAME, of type FNTYPE and | |
97 register it under the built-in function code CODE. If PUBLISH is set then | |
98 the declaration is pushed into the declaration list. CODE is the index | |
99 to the cilk_trees array. *NAME is the name of the function to be added. */ | |
100 | |
101 static tree | |
102 install_builtin (const char *name, tree fntype, enum built_in_function code, | |
103 bool publish) | |
104 { | |
105 tree fndecl = build_fn_decl (name, fntype); | |
106 DECL_BUILT_IN_CLASS (fndecl) = BUILT_IN_NORMAL; | |
107 DECL_FUNCTION_CODE (fndecl) = code; | |
108 if (publish) | |
109 { | |
110 tree t = lang_hooks.decls.pushdecl (fndecl); | |
111 if (t) | |
112 fndecl = t; | |
113 } | |
114 set_builtin_decl (code, fndecl, true); | |
115 return fndecl; | |
116 } | |
117 | |
118 /* Returns a FUNCTION_DECL of type TYPE whose name is *NAME. */ | |
119 | |
120 static tree | |
121 declare_cilk_for_builtin (const char *name, tree type, | |
122 enum built_in_function code) | |
123 { | |
124 tree cb, ft, fn; | |
125 | |
126 cb = build_function_type_list (void_type_node, | |
127 ptr_type_node, type, type, | |
128 NULL_TREE); | |
129 cb = build_pointer_type (cb); | |
130 ft = build_function_type_list (void_type_node, | |
131 cb, ptr_type_node, type, | |
132 integer_type_node, NULL_TREE); | |
133 fn = install_builtin (name, ft, code, false); | |
134 TREE_NOTHROW (fn) = 0; | |
135 | |
136 return fn; | |
137 } | |
138 | |
139 /* Creates and initializes all the built-in Cilk keywords functions and three | |
140 structures: __cilkrts_stack_frame, __cilkrts_pedigree and __cilkrts_worker. | |
141 Detailed information about __cilkrts_stack_frame and | |
142 __cilkrts_worker structures are given in libcilkrts/include/internal/abi.h. | |
143 __cilkrts_pedigree is described in libcilkrts/include/cilk/common.h. */ | |
144 | |
145 void | |
146 cilk_init_builtins (void) | |
147 { | |
148 /* Now build the following __cilkrts_pedigree struct: | |
149 struct __cilkrts_pedigree { | |
150 uint64_t rank; | |
151 struct __cilkrts_pedigree *parent; | |
152 } */ | |
153 | |
154 tree pedigree_type = lang_hooks.types.make_type (RECORD_TYPE); | |
155 tree pedigree_ptr = build_pointer_type (pedigree_type); | |
156 tree field = add_field ("rank", uint64_type_node, NULL_TREE); | |
157 cilk_trees[CILK_TI_PEDIGREE_RANK] = field; | |
158 field = add_field ("parent", pedigree_ptr, field); | |
159 cilk_trees[CILK_TI_PEDIGREE_PARENT] = field; | |
160 finish_builtin_struct (pedigree_type, "__cilkrts_pedigree_GCC", field, | |
161 NULL_TREE); | |
162 lang_hooks.types.register_builtin_type (pedigree_type, | |
163 "__cilkrts_pedigree_t"); | |
164 cilk_pedigree_type_decl = pedigree_type; | |
165 | |
166 /* Build the Cilk Stack Frame: | |
167 struct __cilkrts_stack_frame { | |
168 uint32_t flags; | |
169 uint32_t size; | |
170 struct __cilkrts_stack_frame *call_parent; | |
171 __cilkrts_worker *worker; | |
172 void *except_data; | |
173 void *ctx[4]; | |
174 uint32_t mxcsr; | |
175 uint16_t fpcsr; | |
176 uint16_t reserved; | |
177 __cilkrts_pedigree pedigree; | |
178 }; */ | |
179 | |
180 tree frame = lang_hooks.types.make_type (RECORD_TYPE); | |
181 tree frame_ptr = build_pointer_type (frame); | |
182 tree worker_type = lang_hooks.types.make_type (RECORD_TYPE); | |
183 tree worker_ptr = build_pointer_type (worker_type); | |
184 tree s_type_node = build_int_cst (size_type_node, 4); | |
185 | |
186 tree flags = add_field ("flags", uint32_type_node, NULL_TREE); | |
187 tree size = add_field ("size", uint32_type_node, flags); | |
188 tree parent = add_field ("call_parent", frame_ptr, size); | |
189 tree worker = add_field ("worker", worker_ptr, parent); | |
190 tree except = add_field ("except_data", frame_ptr, worker); | |
191 tree context = add_field ("ctx", | |
192 build_array_type (ptr_type_node, | |
193 build_index_type (s_type_node)), | |
194 except); | |
195 tree mxcsr = add_field ("mxcsr", uint32_type_node, context); | |
196 tree fpcsr = add_field ("fpcsr", uint16_type_node, mxcsr); | |
197 tree reserved = add_field ("reserved", uint16_type_node, fpcsr); | |
198 tree pedigree = add_field ("pedigree", pedigree_type, reserved); | |
199 | |
200 /* Now add them to a common structure whose fields are #defined to something | |
201 that is used at a later stage. */ | |
202 cilk_trees[CILK_TI_FRAME_FLAGS] = flags; | |
203 cilk_trees[CILK_TI_FRAME_PARENT] = parent; | |
204 cilk_trees[CILK_TI_FRAME_WORKER] = worker; | |
205 cilk_trees[CILK_TI_FRAME_EXCEPTION] = except; | |
206 cilk_trees[CILK_TI_FRAME_CONTEXT] = context; | |
207 /* We don't care about reserved, so no need to store it in cilk_trees. */ | |
208 cilk_trees[CILK_TI_FRAME_PEDIGREE] = pedigree; | |
209 TREE_ADDRESSABLE (frame) = 1; | |
210 | |
211 finish_builtin_struct (frame, "__cilkrts_st_frame_GCC", pedigree, NULL_TREE); | |
212 cilk_frame_type_decl = frame; | |
213 lang_hooks.types.register_builtin_type (frame, "__cilkrts_frame_t"); | |
214 | |
215 cilk_frame_ptr_type_decl = build_qualified_type (frame_ptr, | |
216 TYPE_QUAL_VOLATILE); | |
217 /* Now let's do the following worker struct: | |
218 | |
219 struct __cilkrts_worker { | |
220 __cilkrts_stack_frame *volatile *volatile tail; | |
221 __cilkrts_stack_frame *volatile *volatile head; | |
222 __cilkrts_stack_frame *volatile *volatile exc; | |
223 __cilkrts_stack_frame *volatile *volatile protected_tail; | |
224 __cilkrts_stack_frame *volatile *ltq_limit; | |
225 int32_t self; | |
226 global_state_t *g; | |
227 local_state *l; | |
228 cilkred_map *reducer_map; | |
229 __cilkrts_stack_frame *current_stack_frame; | |
230 void *reserved; | |
231 __cilkrts_worker_sysdep_state *sysdep; | |
232 __cilkrts_pedigree pedigree; | |
233 } */ | |
234 | |
235 tree fptr_volatil_type = build_qualified_type (frame_ptr, TYPE_QUAL_VOLATILE); | |
236 tree fptr_volatile_ptr = build_pointer_type (fptr_volatil_type); | |
237 tree fptr_vol_ptr_vol = build_qualified_type (fptr_volatile_ptr, | |
238 TYPE_QUAL_VOLATILE); | |
239 tree g = lang_hooks.types.make_type (RECORD_TYPE); | |
240 finish_builtin_struct (g, "__cilkrts_global_state", NULL_TREE, NULL_TREE); | |
241 tree l = lang_hooks.types.make_type (RECORD_TYPE); | |
242 finish_builtin_struct (l, "__cilkrts_local_state", NULL_TREE, NULL_TREE); | |
243 tree sysdep_t = lang_hooks.types.make_type (RECORD_TYPE); | |
244 finish_builtin_struct (sysdep_t, "__cilkrts_worker_sysdep_state", NULL_TREE, | |
245 NULL_TREE); | |
246 | |
247 field = add_field ("tail", fptr_vol_ptr_vol, NULL_TREE); | |
248 cilk_trees[CILK_TI_WORKER_TAIL] = field; | |
249 field = add_field ("head", fptr_vol_ptr_vol, field); | |
250 field = add_field ("exc", fptr_vol_ptr_vol, field); | |
251 field = add_field ("protected_tail", fptr_vol_ptr_vol, field); | |
252 field = add_field ("ltq_limit", fptr_volatile_ptr, field); | |
253 field = add_field ("self", integer_type_node, field); | |
254 field = add_field ("g", build_pointer_type (g), field); | |
255 field = add_field ("l", build_pointer_type (g), field); | |
256 field = add_field ("reducer_map", ptr_type_node, field); | |
257 field = add_field ("current_stack_frame", frame_ptr, field); | |
258 cilk_trees[CILK_TI_WORKER_CUR] = field; | |
259 field = add_field ("saved_protected_tail", fptr_volatile_ptr, field); | |
260 field = add_field ("sysdep", build_pointer_type (sysdep_t), field); | |
261 field = add_field ("pedigree", pedigree_type, field); | |
262 cilk_trees[CILK_TI_WORKER_PEDIGREE] = field; | |
263 finish_builtin_struct (worker_type, "__cilkrts_worker_GCC", field, | |
264 NULL_TREE); | |
265 | |
266 tree fptr_arglist = tree_cons (NULL_TREE, frame_ptr, void_list_node); | |
267 tree fptr_fun = build_function_type (void_type_node, fptr_arglist); | |
268 | |
269 /* void __cilkrts_enter_frame_1 (__cilkrts_stack_frame *); */ | |
270 cilk_enter_fndecl = install_builtin ("__cilkrts_enter_frame_1", fptr_fun, | |
271 BUILT_IN_CILK_ENTER_FRAME, false); | |
272 | |
273 /* void __cilkrts_enter_frame_fast_1 (__cilkrts_stack_frame *); */ | |
274 cilk_enter_fast_fndecl = | |
275 install_builtin ("__cilkrts_enter_frame_fast_1", fptr_fun, | |
276 BUILT_IN_CILK_ENTER_FRAME_FAST, false); | |
277 | |
278 /* void __cilkrts_pop_frame (__cilkrts_stack_frame *); */ | |
279 cilk_pop_fndecl = install_builtin ("__cilkrts_pop_frame", fptr_fun, | |
280 BUILT_IN_CILK_POP_FRAME, false); | |
281 | |
282 /* void __cilkrts_leave_frame (__cilkrts_stack_frame *); */ | |
283 cilk_leave_fndecl = install_builtin ("__cilkrts_leave_frame", fptr_fun, | |
284 BUILT_IN_CILK_LEAVE_FRAME, false); | |
285 | |
286 /* void __cilkrts_sync (__cilkrts_stack_frame *); */ | |
287 cilk_sync_fndecl = install_builtin ("__cilkrts_sync", fptr_fun, | |
288 BUILT_IN_CILK_SYNC, false); | |
289 | |
290 /* void __cilkrts_detach (__cilkrts_stack_frame *); */ | |
291 cilk_detach_fndecl = install_builtin ("__cilkrts_detach", fptr_fun, | |
292 BUILT_IN_CILK_DETACH, false); | |
293 | |
294 /* __cilkrts_rethrow (struct stack_frame *); */ | |
295 cilk_rethrow_fndecl = install_builtin ("__cilkrts_rethrow", fptr_fun, | |
296 BUILT_IN_CILK_RETHROW, false); | |
297 TREE_NOTHROW (cilk_rethrow_fndecl) = 0; | |
298 | |
299 /* __cilkrts_save_fp_ctrl_state (__cilkrts_stack_frame *); */ | |
300 cilk_save_fp_fndecl = install_builtin ("__cilkrts_save_fp_ctrl_state", | |
301 fptr_fun, BUILT_IN_CILK_SAVE_FP, | |
302 false); | |
303 /* __cilkrts_cilk_for_32 (...); */ | |
304 cilk_for_32_fndecl = declare_cilk_for_builtin ("__cilkrts_cilk_for_32", | |
305 unsigned_intSI_type_node, | |
306 BUILT_IN_CILK_FOR_32); | |
307 /* __cilkrts_cilk_for_64 (...); */ | |
308 cilk_for_64_fndecl = declare_cilk_for_builtin ("__cilkrts_cilk_for_64", | |
309 unsigned_intDI_type_node, | |
310 BUILT_IN_CILK_FOR_64); | |
311 } | |
312 | |
313 /* Get the appropriate frame arguments for CALL that is of type CALL_EXPR. */ | |
314 | |
315 static tree | |
316 get_frame_arg (tree call) | |
317 { | |
318 tree arg, argtype; | |
319 | |
320 gcc_assert (call_expr_nargs (call) >= 1); | |
321 | |
322 arg = CALL_EXPR_ARG (call, 0); | |
323 argtype = TREE_TYPE (arg); | |
324 gcc_assert (TREE_CODE (argtype) == POINTER_TYPE); | |
325 | |
326 argtype = TREE_TYPE (argtype); | |
327 | |
328 /* If it is passed in as an address, then just use the value directly | |
329 since the function is inlined. */ | |
330 if (TREE_CODE (arg) == ADDR_EXPR) | |
331 return TREE_OPERAND (arg, 0); | |
332 return arg; | |
333 } | |
334 | |
335 /* Expands the __cilkrts_pop_frame function call stored in EXP. */ | |
336 | |
337 void | |
338 expand_builtin_cilk_pop_frame (tree exp) | |
339 { | |
340 tree frame = get_frame_arg (exp); | |
341 tree parent = cilk_dot (frame, CILK_TI_FRAME_PARENT, 0); | |
342 | |
343 tree clear_parent = build2 (MODIFY_EXPR, void_type_node, parent, | |
344 build_int_cst (TREE_TYPE (parent), 0)); | |
345 expand_expr (clear_parent, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
346 | |
347 /* During LTO, the is_cilk_function flag gets cleared. | |
348 If __cilkrts_pop_frame is called, then this definitely must be a | |
349 cilk function. */ | |
350 if (cfun) | |
351 cfun->is_cilk_function = 1; | |
352 } | |
353 | |
354 /* Expands the cilk_detach function call stored in EXP. */ | |
355 | |
356 void | |
357 expand_builtin_cilk_detach (tree exp) | |
358 { | |
359 rtx_insn *insn; | |
360 tree fptr = get_frame_arg (exp); | |
361 | |
362 if (fptr == NULL_TREE) | |
363 return; | |
364 | |
365 tree parent = cilk_dot (fptr, CILK_TI_FRAME_PARENT, 0); | |
366 tree worker = cilk_dot (fptr, CILK_TI_FRAME_WORKER, 0); | |
367 tree tail = cilk_arrow (worker, CILK_TI_WORKER_TAIL, 1); | |
368 | |
369 tree faddr = build1 (ADDR_EXPR, cilk_frame_ptr_type_decl, fptr); | |
370 tree enter_frame = build_call_expr (cilk_enter_fast_fndecl, 1, faddr); | |
371 expand_expr (enter_frame, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
372 | |
373 tree pedigree = cilk_dot (fptr, CILK_TI_FRAME_PEDIGREE, 0); | |
374 tree pedigree_rank = cilk_dot (pedigree, CILK_TI_PEDIGREE_RANK, 0); | |
375 tree parent_pedigree = cilk_dot (pedigree, CILK_TI_PEDIGREE_PARENT, 0); | |
376 tree pedigree_parent = cilk_arrow (parent, CILK_TI_FRAME_PEDIGREE, 0); | |
377 tree pedigree_parent_rank = cilk_dot (pedigree_parent, | |
378 CILK_TI_PEDIGREE_RANK, 0); | |
379 tree pedigree_parent_parent = cilk_dot (pedigree_parent, | |
380 CILK_TI_PEDIGREE_PARENT, 0); | |
381 tree worker_pedigree = cilk_arrow (worker, CILK_TI_WORKER_PEDIGREE, 1); | |
382 tree w_pedigree_rank = cilk_dot (worker_pedigree, CILK_TI_PEDIGREE_RANK, 0); | |
383 tree w_pedigree_parent = cilk_dot (worker_pedigree, | |
384 CILK_TI_PEDIGREE_PARENT, 0); | |
385 | |
386 rtx wreg = expand_expr (worker, NULL_RTX, Pmode, EXPAND_NORMAL); | |
387 if (GET_CODE (wreg) != REG) | |
388 wreg = copy_to_reg (wreg); | |
389 rtx preg = expand_expr (parent, NULL_RTX, Pmode, EXPAND_NORMAL); | |
390 | |
391 /* sf.pedigree.rank = worker->pedigree.rank. */ | |
392 tree exp1 = build2 (MODIFY_EXPR, void_type_node, pedigree_rank, | |
393 w_pedigree_rank); | |
394 expand_expr (exp1, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
395 | |
396 /* sf.pedigree.parent = worker->pedigree.parent. */ | |
397 exp1 = build2 (MODIFY_EXPR, void_type_node, parent_pedigree, | |
398 w_pedigree_parent); | |
399 expand_expr (exp1, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
400 | |
401 /* sf.call_parent->pedigree.rank = worker->pedigree.rank. */ | |
402 exp1 = build2 (MODIFY_EXPR, void_type_node, pedigree_parent_rank, | |
403 w_pedigree_rank); | |
404 expand_expr (exp1, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
405 | |
406 /* sf.call_parent->pedigree.parent = worker->pedigree.parent. */ | |
407 exp1 = build2 (MODIFY_EXPR, void_type_node, pedigree_parent_parent, | |
408 w_pedigree_parent); | |
409 expand_expr (exp1, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
410 | |
411 /* sf->worker.pedigree.rank = 0. */ | |
412 exp1 = build2 (MODIFY_EXPR, void_type_node, w_pedigree_rank, | |
413 build_zero_cst (uint64_type_node)); | |
414 expand_expr (exp1, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
415 | |
416 /* sf->pedigree.parent = &sf->pedigree. */ | |
417 exp1 = build2 (MODIFY_EXPR, void_type_node, w_pedigree_parent, | |
418 build1 (ADDR_EXPR, | |
419 build_pointer_type (cilk_pedigree_type_decl), | |
420 pedigree)); | |
421 expand_expr (exp1, const0_rtx, VOIDmode, EXPAND_NORMAL); | |
422 | |
423 /* TMP <- WORKER.TAIL | |
424 *TMP <- PARENT | |
425 TMP <- TMP + 1 | |
426 WORKER.TAIL <- TMP */ | |
427 | |
428 HOST_WIDE_INT worker_tail_offset = | |
429 tree_to_shwi (DECL_FIELD_OFFSET (cilk_trees[CILK_TI_WORKER_TAIL])) + | |
430 tree_to_shwi (DECL_FIELD_BIT_OFFSET (cilk_trees[CILK_TI_WORKER_TAIL])) / | |
431 BITS_PER_UNIT; | |
432 rtx tmem0 = gen_rtx_MEM (Pmode, | |
433 plus_constant (Pmode, wreg, worker_tail_offset)); | |
434 set_mem_attributes (tmem0, tail, 0); | |
435 MEM_NOTRAP_P (tmem0) = 1; | |
436 gcc_assert (MEM_VOLATILE_P (tmem0)); | |
437 rtx treg = copy_to_mode_reg (Pmode, tmem0); | |
438 rtx tmem1 = gen_rtx_MEM (Pmode, treg); | |
439 set_mem_attributes (tmem1, TREE_TYPE (TREE_TYPE (tail)), 0); | |
440 MEM_NOTRAP_P (tmem1) = 1; | |
441 emit_move_insn (tmem1, preg); | |
442 emit_move_insn (treg, plus_constant (Pmode, treg, GET_MODE_SIZE (Pmode))); | |
443 | |
444 /* There is a release barrier (st8.rel, membar #StoreStore, | |
445 sfence, lwsync, etc.) between the two stores. On x86 | |
446 normal volatile stores have proper semantics; the sfence | |
447 would only be needed for nontemporal stores (which we | |
448 could generate using the storent optab, for no benefit | |
449 in this case). | |
450 | |
451 The predicate may return false even for a REG if this is | |
452 the limited release operation that only stores 0. */ | |
453 enum insn_code icode = direct_optab_handler (sync_lock_release_optab, Pmode); | |
454 if (icode != CODE_FOR_nothing | |
455 && insn_data[icode].operand[1].predicate (treg, Pmode) | |
456 && (insn = GEN_FCN (icode) (tmem0, treg)) != NULL_RTX) | |
457 emit_insn (insn); | |
458 else | |
459 emit_move_insn (tmem0, treg); | |
460 | |
461 /* The memory barrier inserted above should not prevent | |
462 the load of flags from being moved before the stores, | |
463 but in practice it does because it is implemented with | |
464 unspec_volatile. In-order RISC machines should | |
465 explicitly load flags earlier. */ | |
466 | |
467 tree flags = cilk_dot (fptr, CILK_TI_FRAME_FLAGS, 0); | |
468 expand_expr (build2 (MODIFY_EXPR, void_type_node, flags, | |
469 build2 (BIT_IOR_EXPR, TREE_TYPE (flags), flags, | |
470 build_int_cst (TREE_TYPE (flags), | |
471 CILK_FRAME_DETACHED))), | |
472 const0_rtx, VOIDmode, EXPAND_NORMAL); | |
473 } | |
474 | |
475 /* Returns a setjmp CALL_EXPR with FRAME->context as its parameter. */ | |
476 | |
477 tree | |
478 cilk_call_setjmp (tree frame) | |
479 { | |
480 tree c = cilk_dot (frame, CILK_TI_FRAME_CONTEXT, false); | |
481 c = build1 (ADDR_EXPR, build_pointer_type (ptr_type_node), c); | |
482 return build_call_expr (builtin_decl_implicit (BUILT_IN_SETJMP), 1, c); | |
483 } | |
484 | |
485 /* This function will expand the _Cilk_sync keyword. */ | |
486 | |
487 static tree | |
488 expand_cilk_sync (void) | |
489 { | |
490 tree frame = cfun->cilk_frame_decl; | |
491 | |
492 /* Cilk_sync is converted to the following code: | |
493 | |
494 sf.pedigree = sf.worker->pedigree; | |
495 if (frame.flags & CILK_FRAME_UNSYNCHED) | |
496 { | |
497 __cilkrts_save_fp_state (&sf); | |
498 if (!builtin_setjmp (sf.ctx) | |
499 __cilkrts_sync (&sf); | |
500 else | |
501 if (sf.flags & CILK_FRAME_EXCEPTING) | |
502 __cilkrts_rethrow (&sf); | |
503 } | |
504 sf.worker->pedigree.rank = sf.worker->pedigree.rank + 1; */ | |
505 | |
506 tree flags = cilk_dot (frame, CILK_TI_FRAME_FLAGS, false); | |
507 | |
508 tree unsynched = fold_build2 (BIT_AND_EXPR, TREE_TYPE (flags), flags, | |
509 build_int_cst (TREE_TYPE (flags), | |
510 CILK_FRAME_UNSYNCHED)); | |
511 | |
512 unsynched = fold_build2 (NE_EXPR, TREE_TYPE (unsynched), unsynched, | |
513 build_int_cst (TREE_TYPE (unsynched), 0)); | |
514 | |
515 tree frame_addr = build1 (ADDR_EXPR, cilk_frame_ptr_type_decl, frame); | |
516 | |
517 /* Check if exception (0x10) bit is set in the sf->flags. */ | |
518 tree except_flag = fold_build2 (BIT_AND_EXPR, TREE_TYPE (flags), flags, | |
519 build_int_cst (TREE_TYPE (flags), | |
520 CILK_FRAME_EXCEPTING)); | |
521 except_flag = fold_build2 (NE_EXPR, TREE_TYPE (except_flag), except_flag, | |
522 build_int_cst (TREE_TYPE (except_flag), 0)); | |
523 | |
524 /* If the exception flag is set then call the __cilkrts_rethrow (&sf). */ | |
525 tree except_cond = fold_build3 (COND_EXPR, void_type_node, except_flag, | |
526 build_call_expr (cilk_rethrow_fndecl, 1, | |
527 frame_addr), | |
528 build_empty_stmt (EXPR_LOCATION (unsynched))); | |
529 | |
530 tree sync_expr = build_call_expr (cilk_sync_fndecl, 1, frame_addr); | |
531 tree setjmp_expr = cilk_call_setjmp (frame); | |
532 setjmp_expr = fold_build2 (EQ_EXPR, TREE_TYPE (setjmp_expr), setjmp_expr, | |
533 build_int_cst (TREE_TYPE (setjmp_expr), 0)); | |
534 | |
535 setjmp_expr = fold_build3 (COND_EXPR, void_type_node, setjmp_expr, | |
536 sync_expr, except_cond); | |
537 tree sync_list = alloc_stmt_list (); | |
538 append_to_statement_list (build_call_expr (cilk_save_fp_fndecl, 1, | |
539 frame_addr), &sync_list); | |
540 append_to_statement_list (setjmp_expr, &sync_list); | |
541 tree sync = fold_build3 (COND_EXPR, void_type_node, unsynched, sync_list, | |
542 build_empty_stmt (EXPR_LOCATION (unsynched))); | |
543 tree parent_pedigree = cilk_dot (frame, CILK_TI_FRAME_PEDIGREE, false); | |
544 tree worker = cilk_dot (frame, CILK_TI_FRAME_WORKER, false); | |
545 tree worker_pedigree = cilk_arrow (worker, CILK_TI_WORKER_PEDIGREE, false); | |
546 tree assign_pedigree = fold_build2 (MODIFY_EXPR, void_type_node, | |
547 parent_pedigree, worker_pedigree); | |
548 tree w_ped_rank = cilk_dot (unshare_expr (worker_pedigree), | |
549 CILK_TI_PEDIGREE_RANK, false); | |
550 tree incr_ped_rank = fold_build2 (PLUS_EXPR, TREE_TYPE (w_ped_rank), | |
551 w_ped_rank, | |
552 build_one_cst (TREE_TYPE (w_ped_rank))); | |
553 incr_ped_rank = fold_build2 (MODIFY_EXPR, void_type_node, w_ped_rank, | |
554 incr_ped_rank); | |
555 tree ret_sync_exp = alloc_stmt_list (); | |
556 append_to_statement_list (assign_pedigree, &ret_sync_exp); | |
557 append_to_statement_list (sync, &ret_sync_exp); | |
558 append_to_statement_list (incr_ped_rank, &ret_sync_exp); | |
559 return ret_sync_exp; | |
560 } | |
561 | |
562 /* Gimplifies the cilk_sync expression passed in *EXPR_P. Returns GS_ALL_DONE | |
563 when finished. */ | |
564 | |
565 void | |
566 gimplify_cilk_sync (tree *expr_p, gimple_seq *pre_p) | |
567 { | |
568 tree sync_expr = expand_cilk_sync (); | |
569 *expr_p = NULL_TREE; | |
570 gimplify_and_add (sync_expr, pre_p); | |
571 } |