|
111
|
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 }
|
