1 /* This file is part of the Intel(R) Cilk(TM) Plus support
2 This file contains the CilkPlus Intrinsics
3 Copyright (C) 2013-2014 Free Software Foundation, Inc.
4 Contributed by Balaji V. Iyer <balaji.v.iyer@intel.com>,
7 This file is part of GCC.
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)
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.
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/>. */
25 #include "coretypes.h"
27 #include "stringpool.h"
29 #include "langhooks.h"
30 #include "pointer-set.h"
31 #include "gimple-expr.h"
33 #include "tree-iterator.h"
34 #include "tree-inline.h"
35 #include "c-family/c-common.h"
38 #include "diagnostic.h"
41 enum add_variable_type
{
42 /* Reference to previously-defined variable. */
44 /* Definition of a new variable in inner-scope. */
46 /* Write to possibly previously-defined variable. */
50 enum cilk_block_type
{
51 /* Indicates a _Cilk_spawn block. 30 was an arbitary number picked for
53 CILK_BLOCK_SPAWN
= 30,
54 /* Indicates _Cilk_for statement block. */
60 /* Kind of function to be created. */
61 enum cilk_block_type type
;
62 /* Signature of helper function. */
64 /* Containing function. */
66 /* Disposition of all variables in the inner statement. */
67 hash_map
<tree
, tree
> *decl_map
;
68 /* True if this function needs a static chain. */
70 /* Arguments to be passed to wrapper function, currently a list. */
72 /* Argument types, a list. */
74 /* Incoming parameters. */
76 /* Outer BLOCK object. */
80 static void extract_free_variables (tree
, struct wrapper_data
*,
81 enum add_variable_type
);
82 static HOST_WIDE_INT cilk_wrapper_count
;
84 /* Marks the CALL_EXPR or FUNCTION_DECL, FCALL, as a spawned function call
85 and the current function as a spawner. Emit error if the function call
86 is outside a function or if a non function-call is spawned. */
89 cilk_set_spawn_marker (location_t loc
, tree fcall
)
91 if (!current_function_decl
)
93 error_at (loc
, "%<_Cilk_spawn%> may only be used inside a function");
96 else if (fcall
== error_mark_node
)
97 /* Error reporting here is not necessary here since if FCALL is an
98 error_mark_node, the function marking it as error would have reported
101 else if (TREE_CODE (fcall
) != CALL_EXPR
102 /* In C++, TARGET_EXPR is generated when we have an overloaded
104 && TREE_CODE (fcall
) != TARGET_EXPR
)
106 error_at (loc
, "only function calls can be spawned");
111 cfun
->calls_cilk_spawn
= true;
116 /* This function will output the exit conditions for a spawn call. */
119 create_cilk_function_exit (tree frame
, bool detaches
, bool needs_sync
)
121 tree epi
= alloc_stmt_list ();
124 append_to_statement_list (build_cilk_sync (), &epi
);
125 tree func_ptr
= build1 (ADDR_EXPR
, cilk_frame_ptr_type_decl
, frame
);
126 tree pop_frame
= build_call_expr (cilk_pop_fndecl
, 1, func_ptr
);
127 tree worker
= cilk_dot (frame
, CILK_TI_FRAME_WORKER
, 0);
128 tree current
= cilk_arrow (worker
, CILK_TI_WORKER_CUR
, 0);
129 tree parent
= cilk_dot (frame
, CILK_TI_FRAME_PARENT
, 0);
130 tree set_current
= build2 (MODIFY_EXPR
, void_type_node
, current
, parent
);
131 append_to_statement_list (set_current
, &epi
);
132 append_to_statement_list (pop_frame
, &epi
);
133 tree call
= build_call_expr (cilk_leave_fndecl
, 1, func_ptr
);
136 tree flags
= cilk_dot (frame
, CILK_TI_FRAME_FLAGS
, false);
137 tree flags_cmp_expr
= fold_build2 (NE_EXPR
, TREE_TYPE (flags
), flags
,
138 build_int_cst (TREE_TYPE (flags
),
139 CILK_FRAME_VERSION
));
140 call
= fold_build3 (COND_EXPR
, void_type_node
, flags_cmp_expr
,
141 call
, build_empty_stmt (EXPR_LOCATION (flags
)));
143 append_to_statement_list (call
, &epi
);
147 /* Trying to get the correct cfun for the FUNCTION_DECL indicated by OUTER. */
150 pop_cfun_to (tree outer
)
153 current_function_decl
= outer
;
154 gcc_assert (cfun
== DECL_STRUCT_FUNCTION (current_function_decl
));
155 gcc_assert (cfun
->decl
== current_function_decl
);
158 /* This function does whatever is necessary to make the compiler emit a newly
159 generated function, FNDECL. */
162 call_graph_add_fn (tree fndecl
)
164 const tree outer
= current_function_decl
;
165 struct function
*f
= DECL_STRUCT_FUNCTION (fndecl
);
166 gcc_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
);
168 f
->is_cilk_function
= 1;
169 f
->curr_properties
= cfun
->curr_properties
;
170 gcc_assert (cfun
== DECL_STRUCT_FUNCTION (outer
));
171 gcc_assert (cfun
->decl
== outer
);
174 cgraph_node::create (fndecl
);
178 /* Return true if this is a tree which is allowed to contain a spawn as
180 A spawn call may be wrapped in a series of unary operations such
181 as conversions. These conversions need not be "useless"
182 to be disregarded because they are retained in the spawned
183 statement. They are bypassed only to look for a spawn
185 A comparison to constant is simple enough to allow, and
186 is used to convert to bool. */
189 cilk_ignorable_spawn_rhs_op (tree exp
)
191 enum tree_code code
= TREE_CODE (exp
);
192 switch (TREE_CODE_CLASS (code
))
195 return code
== ADDR_EXPR
;
197 /* We need the spawn as operand 0 for now. That's where it
198 appears in the only case we really care about, conversion
200 return (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
);
209 /* Helper function for walk_tree. If *TP is a CILK_SPAWN_STMT, then unwrap
210 this "wrapper." The function returns NULL_TREE regardless. */
213 unwrap_cilk_spawn_stmt (tree
*tp
, int *walk_subtrees
, void *)
215 if (TREE_CODE (*tp
) == CILK_SPAWN_STMT
)
217 *tp
= CILK_SPAWN_FN (*tp
);
223 /* Returns true when EXP is a CALL_EXPR with _Cilk_spawn in front. Unwraps
224 CILK_SPAWN_STMT wrapper from the CALL_EXPR in *EXP0 statement. */
227 recognize_spawn (tree exp
, tree
*exp0
)
229 bool spawn_found
= false;
230 if (TREE_CODE (exp
) == CILK_SPAWN_STMT
)
232 /* Remove the CALL_EXPR from CILK_SPAWN_STMT wrapper. */
233 exp
= CILK_SPAWN_FN (exp
);
234 walk_tree (exp0
, unwrap_cilk_spawn_stmt
, NULL
, NULL
);
237 /* _Cilk_spawn can't be wrapped in expression such as PLUS_EXPR. */
238 else if (contains_cilk_spawn_stmt (exp
))
239 error ("invalid use of %<_Cilk_spawn%>");
243 /* Returns true if *EXP0 is a recognized form of spawn. Recognized forms are,
244 after conversion to void, a call expression at outer level or an assignment
245 at outer level with the right hand side being a spawned call.
246 In addition to this, it also unwraps the CILK_SPAWN_STMT cover from the
247 CALL_EXPR that is being spawned.
248 Note that `=' in C++ may turn into a CALL_EXPR rather than a MODIFY_EXPR. */
251 cilk_detect_spawn_and_unwrap (tree
*exp0
)
255 if (!TREE_SIDE_EFFECTS (exp
))
258 /* Strip off any conversion to void. It does not affect whether spawn
259 is supported here. */
260 if (TREE_CODE (exp
) == CONVERT_EXPR
&& VOID_TYPE_P (TREE_TYPE (exp
)))
261 exp
= TREE_OPERAND (exp
, 0);
263 if (TREE_CODE (exp
) == MODIFY_EXPR
|| TREE_CODE (exp
) == INIT_EXPR
)
264 exp
= TREE_OPERAND (exp
, 1);
266 while (cilk_ignorable_spawn_rhs_op (exp
))
267 exp
= TREE_OPERAND (exp
, 0);
269 if (TREE_CODE (exp
) == TARGET_EXPR
)
270 if (TARGET_EXPR_INITIAL (exp
)
271 && TREE_CODE (TARGET_EXPR_INITIAL (exp
)) != AGGR_INIT_EXPR
)
272 exp
= TARGET_EXPR_INITIAL (exp
);
274 /* Happens with C++ TARGET_EXPR. */
275 if (exp
== NULL_TREE
)
278 while (TREE_CODE (exp
) == CLEANUP_POINT_EXPR
|| TREE_CODE (exp
) == EXPR_STMT
)
279 exp
= TREE_OPERAND (exp
, 0);
281 /* Now we should have a CALL_EXPR with a CILK_SPAWN_STMT wrapper around
282 it, or return false. */
283 if (recognize_spawn (exp
, exp0
))
288 /* This function will build and return a FUNCTION_DECL using information
292 create_cilk_helper_decl (struct wrapper_data
*wd
)
295 if (wd
->type
== CILK_BLOCK_FOR
)
296 sprintf (name
, "_cilk_for_" HOST_WIDE_INT_PRINT_DEC
, cilk_wrapper_count
++);
297 else if (wd
->type
== CILK_BLOCK_SPAWN
)
298 sprintf (name
, "_cilk_spn_" HOST_WIDE_INT_PRINT_DEC
, cilk_wrapper_count
++);
302 clean_symbol_name (name
);
303 tree fndecl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
304 get_identifier (name
), wd
->fntype
);
306 TREE_PUBLIC (fndecl
) = 0;
307 TREE_STATIC (fndecl
) = 1;
308 TREE_USED (fndecl
) = 1;
309 DECL_ARTIFICIAL (fndecl
) = 0;
310 DECL_IGNORED_P (fndecl
) = 0;
311 DECL_EXTERNAL (fndecl
) = 0;
313 DECL_CONTEXT (fndecl
) = wd
->context
;
314 tree block
= make_node (BLOCK
);
315 DECL_INITIAL (fndecl
) = block
;
316 TREE_USED (block
) = 1;
317 BLOCK_SUPERCONTEXT (block
) = fndecl
;
318 gcc_assert (!DECL_SAVED_TREE (fndecl
));
320 /* Inlining would defeat the purpose of this wrapper.
321 Either it secretly switches stack frames or it allocates
322 a stable stack frame to hold function arguments even if
323 the parent stack frame is stolen. */
324 DECL_UNINLINABLE (fndecl
) = 1;
326 tree result_decl
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
, NULL_TREE
,
328 DECL_ARTIFICIAL (result_decl
) = 0;
329 DECL_IGNORED_P (result_decl
) = 1;
330 DECL_CONTEXT (result_decl
) = fndecl
;
331 DECL_RESULT (fndecl
) = result_decl
;
336 /* A function used by walk tree to find wrapper parms. */
339 wrapper_parm_cb (tree
const &key0
, tree
*val0
, wrapper_data
*wd
)
345 if (val
== error_mark_node
|| val
== arg
)
348 if (TREE_CODE (val
) == PAREN_EXPR
)
350 /* We should not reach here with a register receiver.
351 We may see a register variable modified in the
352 argument list. Because register variables are
353 worker-local we don't need to work hard to support
354 them in code that spawns. */
355 if ((TREE_CODE (arg
) == VAR_DECL
) && DECL_HARD_REGISTER (arg
))
357 error_at (EXPR_LOCATION (arg
),
358 "explicit register variable %qD may not be modified in "
360 arg
= null_pointer_node
;
363 arg
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), arg
);
365 val
= TREE_OPERAND (val
, 0);
367 gcc_assert (TREE_CODE (val
) == INDIRECT_REF
);
368 parm
= TREE_OPERAND (val
, 0);
373 TREE_CHAIN (parm
) = wd
->parms
;
375 wd
->argtypes
= tree_cons (NULL_TREE
, TREE_TYPE (parm
), wd
->argtypes
);
376 wd
->arglist
= tree_cons (NULL_TREE
, arg
, wd
->arglist
);
380 /* This function is used to build a wrapper of a certain type. */
383 build_wrapper_type (struct wrapper_data
*wd
)
385 wd
->arglist
= NULL_TREE
;
386 wd
->parms
= NULL_TREE
;
387 wd
->argtypes
= void_list_node
;
389 wd
->decl_map
->traverse
<wrapper_data
*, wrapper_parm_cb
> (wd
);
390 gcc_assert (wd
->type
!= CILK_BLOCK_FOR
);
392 /* Now build a function.
393 Its return type is void (all side effects are via explicit parameters).
394 Its parameters are WRAPPER_PARMS with type WRAPPER_TYPES.
395 Actual arguments in the caller are WRAPPER_ARGS. */
396 wd
->fntype
= build_function_type (void_type_node
, wd
->argtypes
);
399 /* This function checks all the CALL_EXPRs in *TP found by cilk_outline. */
402 check_outlined_calls (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
405 bool *throws
= (bool *) data
;
409 if (TREE_CODE (t
) != CALL_EXPR
)
411 flags
= call_expr_flags (t
);
413 if (!(flags
& ECF_NOTHROW
) && flag_exceptions
)
415 if (flags
& ECF_RETURNS_TWICE
)
416 error_at (EXPR_LOCATION (t
),
417 "cannot spawn call to function that returns twice");
421 /* Each DECL in the source code (spawned statement) is passed to this function
422 once. Each instance of the DECL is replaced with the result of this
425 The parameters of the wrapper should have been entered into the map already.
426 This function only deals with variables with scope limited to the
427 spawned expression. */
430 copy_decl_for_cilk (tree decl
, copy_body_data
*id
)
432 switch (TREE_CODE (decl
))
435 return copy_decl_no_change (decl
, id
);
438 error_at (EXPR_LOCATION (decl
), "invalid use of label %q+D in "
441 return error_mark_node
;
445 /* RESULT_DECL and PARM_DECL has already been entered into the map. */
448 return error_mark_node
;
452 /* Copy all local variables. */
455 for_local_cb (tree
const &k
, tree
*vp
, copy_body_data
*id
)
459 if (v
== error_mark_node
)
460 *vp
= copy_decl_no_change (k
, id
);
464 /* Copy all local declarations from a _Cilk_spawned function's body. */
467 wrapper_local_cb (tree
const &key
, tree
*vp
, copy_body_data
*id
)
471 if (val
== error_mark_node
)
472 *vp
= copy_decl_for_cilk (key
, id
);
477 /* Alter a tree STMT from OUTER_FN to form the body of INNER_FN. */
480 cilk_outline (tree inner_fn
, tree
*stmt_p
, void *w
)
482 struct wrapper_data
*wd
= (struct wrapper_data
*) w
;
483 const tree outer_fn
= wd
->context
;
484 const bool nested
= (wd
->type
== CILK_BLOCK_FOR
);
488 DECL_STATIC_CHAIN (outer_fn
) = 1;
490 memset (&id
, 0, sizeof (id
));
491 /* Copy from the function containing the spawn... */
492 id
.src_fn
= outer_fn
;
494 /* ...to the wrapper. */
495 id
.dst_fn
= inner_fn
;
496 id
.src_cfun
= DECL_STRUCT_FUNCTION (outer_fn
);
498 /* There shall be no RETURN in spawn helper. */
500 id
.decl_map
= wd
->decl_map
;
501 id
.copy_decl
= nested
? copy_decl_no_change
: copy_decl_for_cilk
;
502 id
.block
= DECL_INITIAL (inner_fn
);
503 id
.transform_lang_insert_block
= NULL
;
505 id
.transform_new_cfg
= true;
506 id
.transform_call_graph_edges
= CB_CGE_MOVE
;
507 id
.remap_var_for_cilk
= true;
508 id
.regimplify
= true; /* unused? */
510 insert_decl_map (&id
, wd
->block
, DECL_INITIAL (inner_fn
));
512 /* We don't want the private variables any more. */
514 wd
->decl_map
->traverse
<copy_body_data
*, for_local_cb
> (&id
);
516 wd
->decl_map
->traverse
<copy_body_data
*, wrapper_local_cb
> (&id
);
518 walk_tree (stmt_p
, copy_tree_body_r
, (void *) &id
, NULL
);
520 /* See if this function can throw or calls something that should
521 not be spawned. The exception part is only necessary if
522 flag_exceptions && !flag_non_call_exceptions. */
524 (void) walk_tree_without_duplicates (stmt_p
, check_outlined_calls
, &throws
);
527 /* Generate the body of a wrapper function that assigns the
528 result of the expression RHS into RECEIVER. RECEIVER must
529 be NULL if this is not a spawn -- the wrapper will return
530 a value. If this is a spawn, the wrapper will return void. */
533 create_cilk_wrapper_body (tree stmt
, struct wrapper_data
*wd
)
535 const tree outer
= current_function_decl
;
539 /* Build the type of the wrapper and its argument list from the
540 variables that it requires. */
541 build_wrapper_type (wd
);
543 /* Emit a function that takes WRAPPER_PARMS incoming and applies ARGS
544 (modified) to the wrapped function. Return the wrapper and modified ARGS
545 to the caller to generate a function call. */
546 fndecl
= create_cilk_helper_decl (wd
);
547 push_struct_function (fndecl
);
548 if (wd
->nested
&& (wd
->type
== CILK_BLOCK_FOR
))
550 gcc_assert (TREE_VALUE (wd
->arglist
) == NULL_TREE
);
551 TREE_VALUE (wd
->arglist
) = build2 (FDESC_EXPR
, ptr_type_node
,
552 fndecl
, integer_one_node
);
554 DECL_ARGUMENTS (fndecl
) = wd
->parms
;
556 for (p
= wd
->parms
; p
; p
= TREE_CHAIN (p
))
557 DECL_CONTEXT (p
) = fndecl
;
559 gcc_assert (!DECL_SAVED_TREE (fndecl
));
560 cilk_install_body_with_frame_cleanup (fndecl
, stmt
, (void *) wd
);
561 gcc_assert (DECL_SAVED_TREE (fndecl
));
565 /* Recognize the new function. */
566 call_graph_add_fn (fndecl
);
570 /* Initializes the wrapper data structure. */
573 init_wd (struct wrapper_data
*wd
, enum cilk_block_type type
)
576 wd
->fntype
= NULL_TREE
;
577 wd
->context
= current_function_decl
;
578 wd
->decl_map
= new hash_map
<tree
, tree
>;
579 /* _Cilk_for bodies are always nested. Others start off as
581 wd
->nested
= (type
== CILK_BLOCK_FOR
);
582 wd
->arglist
= NULL_TREE
;
583 wd
->argtypes
= NULL_TREE
;
584 wd
->block
= NULL_TREE
;
587 /* Clears the wrapper data structure. */
590 free_wd (struct wrapper_data
*wd
)
594 wd
->arglist
= NULL_TREE
;
595 wd
->argtypes
= NULL_TREE
;
596 wd
->parms
= NULL_TREE
;
600 /* Given a variable in an expression to be extracted into
601 a helper function, declare the helper function parameter
604 On entry the value of the (key, value) pair may be
606 (*, error_mark_node) -- Variable is private to helper function,
609 (var, var) -- Reference to outer scope (function or global scope).
611 (var, integer 0) -- Capture by value, save newly-declared PARM_DECL
612 for value in value slot.
614 (var, integer 1) -- Capture by reference, declare pointer to type
615 as new PARM_DECL and store (spawn_stmt (indirect_ref (parm)).
617 (var, ???) -- Pure output argument, handled similarly to above.
621 declare_one_free_variable (tree
const &var0
, tree
*map0
, wrapper_data
&)
623 const_tree var
= var0
;
625 tree var_type
= TREE_TYPE (var
), arg_type
;
629 gcc_assert (DECL_P (var
));
631 /* Ignore truly local variables. */
632 if (map
== error_mark_node
)
634 /* Ignore references to the parent function. */
638 gcc_assert (TREE_CODE (map
) == INTEGER_CST
);
640 /* A value is passed by reference if:
642 1. It is addressable, so that a copy may not be made.
643 2. It is modified in the spawned statement.
644 In the future this function may want to arrange
645 a warning if the spawned statement is a loop body
646 because an output argument would indicate a race.
647 Note: Earlier passes must have marked the variable addressable.
648 3. It is expensive to copy. */
650 (TREE_ADDRESSABLE (var_type
)
651 /* Arrays must be passed by reference. This is required for C
652 semantics -- arrays are not first class objects. Other
653 aggregate types can and should be passed by reference if
654 they are not passed to the spawned function. We aren't yet
655 distinguishing safe uses in argument calculation from unsafe
656 uses as outgoing function arguments, so we make a copy to
657 stabilize the value. */
658 || TREE_CODE (var_type
) == ARRAY_TYPE
659 || (tree
) map
== integer_one_node
);
662 var_type
= build_qualified_type (build_pointer_type (var_type
),
664 gcc_assert (!TREE_ADDRESSABLE (var_type
));
666 /* Maybe promote to int. */
667 if (INTEGRAL_TYPE_P (var_type
) && COMPLETE_TYPE_P (var_type
)
668 && tree_int_cst_lt (TYPE_SIZE (var_type
), TYPE_SIZE (integer_type_node
)))
669 arg_type
= integer_type_node
;
673 parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
, var_type
);
674 DECL_ARG_TYPE (parm
) = arg_type
;
675 DECL_ARTIFICIAL (parm
) = 0;
676 TREE_READONLY (parm
) = 1;
680 parm
= build1 (INDIRECT_REF
, TREE_TYPE (var_type
), parm
);
681 parm
= build1 (PAREN_EXPR
, void_type_node
, parm
);
687 /* Returns a wrapper function for a _Cilk_spawn. */
690 create_cilk_wrapper (tree exp
, tree
*args_out
)
692 struct wrapper_data wd
;
695 init_wd (&wd
, CILK_BLOCK_SPAWN
);
697 if (TREE_CODE (exp
) == CONVERT_EXPR
)
698 exp
= TREE_OPERAND (exp
, 0);
700 /* Special handling for top level INIT_EXPR. Usually INIT_EXPR means the
701 variable is defined in the spawned expression and can be private to the
702 spawn helper. A top level INIT_EXPR defines a variable to be initialized
703 by spawn and the variable must remain in the outer function. */
704 if (TREE_CODE (exp
) == INIT_EXPR
)
706 extract_free_variables (TREE_OPERAND (exp
, 0), &wd
, ADD_WRITE
);
707 extract_free_variables (TREE_OPERAND (exp
, 1), &wd
, ADD_READ
);
708 /* TREE_TYPE should be void. Be defensive. */
709 if (TREE_TYPE (exp
) != void_type_node
)
710 extract_free_variables (TREE_TYPE (exp
), &wd
, ADD_READ
);
713 extract_free_variables (exp
, &wd
, ADD_READ
);
714 wd
.decl_map
->traverse
<wrapper_data
&, declare_one_free_variable
> (wd
);
715 wd
.block
= TREE_BLOCK (exp
);
717 wd
.block
= DECL_INITIAL (current_function_decl
);
719 /* Now fvars maps the old variable to incoming variable. Update
720 the expression and arguments to refer to the new names. */
721 fndecl
= create_cilk_wrapper_body (exp
, &wd
);
722 *args_out
= wd
.arglist
;
729 /* Transform *SPAWN_P, a spawned CALL_EXPR, to gimple. *SPAWN_P can be a
730 CALL_EXPR, INIT_EXPR or MODIFY_EXPR. Returns GS_OK if everything is fine,
731 and GS_UNHANDLED, otherwise. */
734 gimplify_cilk_spawn (tree
*spawn_p
)
736 tree expr
= *spawn_p
;
737 tree function
, call1
, call2
, new_args
;
738 tree ii_args
= NULL_TREE
;
739 int total_args
= 0, ii
= 0;
741 tree setjmp_cond_expr
= NULL_TREE
;
742 tree setjmp_expr
, spawn_expr
, setjmp_value
= NULL_TREE
;
744 cfun
->calls_cilk_spawn
= 1;
745 cfun
->is_cilk_function
= 1;
747 /* Remove CLEANUP_POINT_EXPR and EXPR_STMT from *spawn_p. */
748 while (TREE_CODE (expr
) == CLEANUP_POINT_EXPR
749 || TREE_CODE (expr
) == EXPR_STMT
)
750 expr
= TREE_OPERAND (expr
, 0);
753 function
= create_cilk_wrapper (expr
, &new_args
);
755 /* This should give the number of parameters. */
756 total_args
= list_length (new_args
);
758 arg_array
= XNEWVEC (tree
, total_args
);
763 for (ii
= 0; ii
< total_args
; ii
++)
765 arg_array
[ii
] = TREE_VALUE (ii_args
);
766 ii_args
= TREE_CHAIN (ii_args
);
769 TREE_USED (function
) = 1;
770 rest_of_decl_compilation (function
, 0, 0);
772 call1
= cilk_call_setjmp (cfun
->cilk_frame_decl
);
774 if (arg_array
== NULL
|| *arg_array
== NULL_TREE
)
775 call2
= build_call_expr (function
, 0);
777 call2
= build_call_expr_loc_array (EXPR_LOCATION (*spawn_p
), function
,
778 total_args
, arg_array
);
779 *spawn_p
= alloc_stmt_list ();
780 tree f_ptr_type
= build_pointer_type (TREE_TYPE (cfun
->cilk_frame_decl
));
781 tree frame_ptr
= build1 (ADDR_EXPR
, f_ptr_type
, cfun
->cilk_frame_decl
);
782 tree save_fp
= build_call_expr (cilk_save_fp_fndecl
, 1, frame_ptr
);
783 append_to_statement_list (save_fp
, spawn_p
);
784 setjmp_value
= create_tmp_var (TREE_TYPE (call1
), NULL
);
785 setjmp_expr
= fold_build2 (MODIFY_EXPR
, void_type_node
, setjmp_value
, call1
);
787 append_to_statement_list_force (setjmp_expr
, spawn_p
);
789 setjmp_cond_expr
= fold_build2 (EQ_EXPR
, TREE_TYPE (call1
), setjmp_value
,
790 build_int_cst (TREE_TYPE (call1
), 0));
791 spawn_expr
= fold_build3 (COND_EXPR
, void_type_node
, setjmp_cond_expr
,
792 call2
, build_empty_stmt (EXPR_LOCATION (call1
)));
793 append_to_statement_list (spawn_expr
, spawn_p
);
798 /* Make the frames necessary for a spawn call. */
801 make_cilk_frame (tree fn
)
803 struct function
*f
= DECL_STRUCT_FUNCTION (fn
);
806 if (f
->cilk_frame_decl
)
807 return f
->cilk_frame_decl
;
809 decl
= build_decl (EXPR_LOCATION (fn
), VAR_DECL
, NULL_TREE
,
810 cilk_frame_type_decl
);
811 DECL_CONTEXT (decl
) = fn
;
812 DECL_SEEN_IN_BIND_EXPR_P (decl
) = 1;
813 f
->cilk_frame_decl
= decl
;
817 /* Returns a STATEMENT_LIST with all the pedigree operations required for
818 install body with frame cleanup functions. FRAME_PTR is the pointer to
819 __cilkrts_stack_frame created by make_cilk_frame. */
822 cilk_install_body_pedigree_operations (tree frame_ptr
)
824 tree body_list
= alloc_stmt_list ();
825 tree enter_frame
= build_call_expr (cilk_enter_fast_fndecl
, 1, frame_ptr
);
826 append_to_statement_list (enter_frame
, &body_list
);
828 tree parent
= cilk_arrow (frame_ptr
, CILK_TI_FRAME_PARENT
, 0);
829 tree worker
= cilk_arrow (frame_ptr
, CILK_TI_FRAME_WORKER
, 0);
831 tree pedigree
= cilk_arrow (frame_ptr
, CILK_TI_FRAME_PEDIGREE
, 0);
832 tree pedigree_rank
= cilk_dot (pedigree
, CILK_TI_PEDIGREE_RANK
, 0);
833 tree parent_pedigree
= cilk_dot (pedigree
, CILK_TI_PEDIGREE_PARENT
, 0);
834 tree pedigree_parent
= cilk_arrow (parent
, CILK_TI_FRAME_PEDIGREE
, 0);
835 tree pedigree_parent_rank
= cilk_dot (pedigree_parent
,
836 CILK_TI_PEDIGREE_RANK
, 0);
837 tree pedigree_parent_parent
= cilk_dot (pedigree_parent
,
838 CILK_TI_PEDIGREE_PARENT
, 0);
839 tree worker_pedigree
= cilk_arrow (worker
, CILK_TI_WORKER_PEDIGREE
, 1);
840 tree w_pedigree_rank
= cilk_dot (worker_pedigree
, CILK_TI_PEDIGREE_RANK
, 0);
841 tree w_pedigree_parent
= cilk_dot (worker_pedigree
,
842 CILK_TI_PEDIGREE_PARENT
, 0);
844 /* sf.pedigree.rank = worker->pedigree.rank. */
845 tree exp1
= build2 (MODIFY_EXPR
, void_type_node
, pedigree_rank
,
847 append_to_statement_list (exp1
, &body_list
);
849 /* sf.pedigree.parent = worker->pedigree.parent. */
850 exp1
= build2 (MODIFY_EXPR
, void_type_node
, parent_pedigree
,
852 append_to_statement_list (exp1
, &body_list
);
854 /* sf.call_parent->pedigree.rank = worker->pedigree.rank. */
855 exp1
= build2 (MODIFY_EXPR
, void_type_node
, pedigree_parent_rank
,
857 append_to_statement_list (exp1
, &body_list
);
859 /* sf.call_parent->pedigree.parent = worker->pedigree.parent. */
860 exp1
= build2 (MODIFY_EXPR
, void_type_node
, pedigree_parent_parent
,
862 append_to_statement_list (exp1
, &body_list
);
864 /* sf->worker.pedigree.rank = 0. */
865 exp1
= build2 (MODIFY_EXPR
, void_type_node
, w_pedigree_rank
,
866 build_zero_cst (uint64_type_node
));
867 append_to_statement_list (exp1
, &body_list
);
869 /* sf->pedigree.parent = &sf->pedigree. */
870 exp1
= build2 (MODIFY_EXPR
, void_type_node
, w_pedigree_parent
,
872 build_pointer_type (cilk_pedigree_type_decl
),
874 append_to_statement_list (exp1
, &body_list
);
878 /* Add a new variable, VAR to a variable list in WD->DECL_MAP. HOW indicates
879 whether the variable is previously defined, currently defined, or a variable
880 that is being written to. */
883 add_variable (struct wrapper_data
*wd
, tree var
, enum add_variable_type how
)
885 tree
*valp
= wd
->decl_map
->get (var
);
888 tree val
= (tree
) *valp
;
889 /* If the variable is local, do nothing. */
890 if (val
== error_mark_node
)
892 /* If the variable was entered with itself as value,
893 meaning it belongs to an outer scope, do not alter
897 /* A statement expression may cause a variable to be
898 bound twice, once in BIND_EXPR and again in a
899 DECL_EXPR. That case caused a return in the
900 test above. Any other duplicate definition is
902 gcc_assert (how
!= ADD_BIND
);
903 if (how
!= ADD_WRITE
)
905 /* This variable might have been entered as read but is now written. */
912 tree val
= NULL_TREE
;
914 /* Nested function rewriting silently discards hard register
915 assignments for function scope variables, and they wouldn't
916 work anyway. Warn here. This misses one case: if the
917 register variable is used as the loop bound or increment it
918 has already been added to the map. */
919 if ((how
!= ADD_BIND
) && (TREE_CODE (var
) == VAR_DECL
)
920 && !DECL_EXTERNAL (var
) && DECL_HARD_REGISTER (var
))
921 warning (0, "register assignment ignored for %qD used in Cilk block",
926 /* ADD_BIND means always make a fresh new variable. */
928 val
= error_mark_node
;
931 1. For cilk_for, refer to the outer scope definition as-is
932 2. For a spawned block, take a scalar in an rgument
933 and otherwise refer to the outer scope definition as-is.
934 3. For a spawned call, take a scalar in an argument. */
941 case CILK_BLOCK_SPAWN
:
942 if (TREE_ADDRESSABLE (var
))
948 val
= integer_zero_node
;
959 case CILK_BLOCK_SPAWN
:
960 if (TREE_ADDRESSABLE (var
))
961 val
= integer_one_node
;
970 wd
->decl_map
->put (var
, val
);
974 /* Find the variables referenced in an expression T. This does not avoid
975 duplicates because a variable may be read in one context and written in
976 another. HOW describes the context in which the reference is seen. If
977 NESTED is true a nested function is being generated and variables in the
978 original context should not be remapped. */
981 extract_free_variables (tree t
, struct wrapper_data
*wd
,
982 enum add_variable_type how
)
987 enum tree_code code
= TREE_CODE (t
);
988 bool is_expr
= IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
));
991 extract_free_variables (TREE_TYPE (t
), wd
, ADD_READ
);
996 case IDENTIFIER_NODE
:
1003 case PLACEHOLDER_EXPR
:
1007 /* These do not contain variable references. */
1011 /* Currently we don't see SSA_NAME. */
1012 extract_free_variables (SSA_NAME_VAR (t
), wd
, how
);
1016 /* This might be a reference to a label outside the Cilk block,
1017 which is an error, or a reference to a label in the Cilk block
1018 that we haven't seen yet. We can't tell. Ignore it. An
1019 invalid use will cause an error later in copy_decl_for_cilk. */
1023 if (wd
->type
!= CILK_BLOCK_SPAWN
)
1024 TREE_ADDRESSABLE (t
) = 1;
1027 if (!TREE_STATIC (t
) && !DECL_EXTERNAL (t
))
1028 add_variable (wd
, t
, how
);
1031 case NON_LVALUE_EXPR
:
1034 extract_free_variables (TREE_OPERAND (t
, 0), wd
, ADD_READ
);
1039 extract_free_variables (TREE_OPERAND (t
, 0), wd
, ADD_BIND
);
1040 extract_free_variables (TREE_OPERAND (t
, 1), wd
, ADD_READ
);
1044 case PREDECREMENT_EXPR
:
1045 case PREINCREMENT_EXPR
:
1046 case POSTDECREMENT_EXPR
:
1047 case POSTINCREMENT_EXPR
:
1048 /* These write their result. */
1049 extract_free_variables (TREE_OPERAND (t
, 0), wd
, ADD_WRITE
);
1050 extract_free_variables (TREE_OPERAND (t
, 1), wd
, ADD_READ
);
1054 /* This might modify its argument, and the value needs to be
1055 passed by reference in any case to preserve identity and
1056 type if is a promoting type. In the case of a nested loop
1057 just notice that we touch the variable. It will already
1058 be addressable, and marking it modified will cause a spurious
1059 warning about writing the control variable. */
1060 if (wd
->type
!= CILK_BLOCK_SPAWN
)
1061 extract_free_variables (TREE_OPERAND (t
, 0), wd
, ADD_READ
);
1063 extract_free_variables (TREE_OPERAND (t
, 0), wd
, ADD_WRITE
);
1067 /* Treating ARRAY_REF and BIT_FIELD_REF identically may
1068 mark the array as written but the end result is correct
1069 because the array is passed by pointer anyway. */
1071 /* Propagate the access type to the object part of which
1072 is being accessed here. As for ADDR_EXPR, don't do this
1073 in a nested loop, unless the access is to a fixed index. */
1074 if (wd
->type
!= CILK_BLOCK_FOR
|| TREE_CONSTANT (TREE_OPERAND (t
, 1)))
1075 extract_free_variables (TREE_OPERAND (t
, 0), wd
, how
);
1077 extract_free_variables (TREE_OPERAND (t
, 0), wd
, ADD_READ
);
1078 extract_free_variables (TREE_OPERAND (t
, 1), wd
, ADD_READ
);
1079 extract_free_variables (TREE_OPERAND (t
, 2), wd
, ADD_READ
);
1083 extract_free_variables (TREE_PURPOSE (t
), wd
, ADD_READ
);
1084 extract_free_variables (TREE_VALUE (t
), wd
, ADD_READ
);
1085 extract_free_variables (TREE_CHAIN (t
), wd
, ADD_READ
);
1090 int len
= TREE_VEC_LENGTH (t
);
1092 for (i
= 0; i
< len
; i
++)
1093 extract_free_variables (TREE_VEC_ELT (t
, i
), wd
, ADD_READ
);
1100 for (ii
= 0; ii
< VECTOR_CST_NELTS (t
); ii
++)
1101 extract_free_variables (VECTOR_CST_ELT (t
, ii
), wd
, ADD_READ
);
1106 extract_free_variables (TREE_REALPART (t
), wd
, ADD_READ
);
1107 extract_free_variables (TREE_IMAGPART (t
), wd
, ADD_READ
);
1113 for (decl
= BIND_EXPR_VARS (t
); decl
; decl
= TREE_CHAIN (decl
))
1115 add_variable (wd
, decl
, ADD_BIND
);
1116 /* A self-referential initialization is no problem because
1117 we already entered the variable into the map as local. */
1118 extract_free_variables (DECL_INITIAL (decl
), wd
, ADD_READ
);
1119 extract_free_variables (DECL_SIZE (decl
), wd
, ADD_READ
);
1120 extract_free_variables (DECL_SIZE_UNIT (decl
), wd
, ADD_READ
);
1122 extract_free_variables (BIND_EXPR_BODY (t
), wd
, ADD_READ
);
1126 case STATEMENT_LIST
:
1128 tree_stmt_iterator i
;
1129 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
1130 extract_free_variables (*tsi_stmt_ptr (i
), wd
, ADD_READ
);
1136 extract_free_variables (TREE_OPERAND (t
, 0), wd
, ADD_BIND
);
1137 extract_free_variables (TREE_OPERAND (t
, 1), wd
, ADD_READ
);
1138 extract_free_variables (TREE_OPERAND (t
, 2), wd
, ADD_READ
);
1139 if (TREE_OPERAND (t
, 3) != TREE_OPERAND (t
, 1))
1140 extract_free_variables (TREE_OPERAND (t
, 3), wd
, ADD_READ
);
1145 if (TREE_NO_WARNING (t
))
1147 gcc_assert (errorcount
);
1153 if (TREE_CODE (DECL_EXPR_DECL (t
)) != TYPE_DECL
)
1154 extract_free_variables (DECL_EXPR_DECL (t
), wd
, ADD_BIND
);
1160 extract_free_variables (TYPE_MIN_VALUE (t
), wd
, ADD_READ
);
1161 extract_free_variables (TYPE_MAX_VALUE (t
), wd
, ADD_READ
);
1165 extract_free_variables (TREE_TYPE (t
), wd
, ADD_READ
);
1169 extract_free_variables (TREE_TYPE (t
), wd
, ADD_READ
);
1170 extract_free_variables (TYPE_DOMAIN (t
), wd
, ADD_READ
);
1174 extract_free_variables (TYPE_FIELDS (t
), wd
, ADD_READ
);
1178 extract_free_variables (TYPE_ARG_TYPES (t
), wd
, ADD_READ
);
1179 extract_free_variables (TYPE_METHOD_BASETYPE (t
), wd
, ADD_READ
);
1182 case AGGR_INIT_EXPR
:
1187 if (TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
1189 len
= TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
1191 for (ii
= 0; ii
< len
; ii
++)
1192 extract_free_variables (TREE_OPERAND (t
, ii
), wd
, ADD_READ
);
1193 extract_free_variables (TREE_TYPE (t
), wd
, ADD_READ
);
1200 unsigned HOST_WIDE_INT idx
= 0;
1201 constructor_elt
*ce
;
1202 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
1203 extract_free_variables (ce
->value
, wd
, ADD_READ
);
1212 /* Walk over all the sub-trees of this operand. */
1213 len
= TREE_CODE_LENGTH (code
);
1215 /* Go through the subtrees. We need to do this in forward order so
1216 that the scope of a FOR_EXPR is handled properly. */
1217 for (i
= 0; i
< len
; ++i
)
1218 extract_free_variables (TREE_OPERAND (t
, i
), wd
, ADD_READ
);
1223 /* Add appropriate frames needed for a Cilk spawned function call, FNDECL.
1224 Returns the __cilkrts_stack_frame * variable. */
1227 insert_cilk_frame (tree fndecl
)
1229 tree addr
, body
, enter
, out
, orig_body
;
1230 location_t loc
= EXPR_LOCATION (fndecl
);
1232 if (!cfun
|| cfun
->decl
!= fndecl
)
1233 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1235 tree decl
= cfun
->cilk_frame_decl
;
1238 tree
*saved_tree
= &DECL_SAVED_TREE (fndecl
);
1239 decl
= make_cilk_frame (fndecl
);
1240 add_local_decl (cfun
, decl
);
1242 addr
= build1 (ADDR_EXPR
, cilk_frame_ptr_type_decl
, decl
);
1243 enter
= build_call_expr (cilk_enter_fndecl
, 1, addr
);
1244 out
= create_cilk_function_exit (cfun
->cilk_frame_decl
, false, true);
1246 /* The new body will be:
1247 __cilkrts_enter_frame_1 (&sf);
1252 __cilkrts_pop_frame (&sf);
1253 __cilkrts_leave_frame (&sf);
1256 body
= alloc_stmt_list ();
1257 orig_body
= *saved_tree
;
1259 if (TREE_CODE (orig_body
) == BIND_EXPR
)
1260 orig_body
= BIND_EXPR_BODY (orig_body
);
1262 append_to_statement_list (enter
, &body
);
1263 append_to_statement_list (build_stmt (loc
, TRY_FINALLY_EXPR
, orig_body
,
1265 if (TREE_CODE (*saved_tree
) == BIND_EXPR
)
1266 BIND_EXPR_BODY (*saved_tree
) = body
;
1273 /* Wraps CALL, a CALL_EXPR, into a CILK_SPAWN_STMT tree and returns it. */
1276 build_cilk_spawn (location_t loc
, tree call
)
1278 if (!cilk_set_spawn_marker (loc
, call
))
1279 return error_mark_node
;
1280 tree spawn_stmt
= build1 (CILK_SPAWN_STMT
, TREE_TYPE (call
), call
);
1281 TREE_SIDE_EFFECTS (spawn_stmt
) = 1;
1285 /* Returns a tree of type CILK_SYNC_STMT. */
1288 build_cilk_sync (void)
1290 tree sync
= build0 (CILK_SYNC_STMT
, void_type_node
);
1291 TREE_SIDE_EFFECTS (sync
) = 1;
1295 /* Helper for contains_cilk_spawn_stmt, callback for walk_tree. Return
1296 non-null tree if TP contains CILK_SPAWN_STMT. */
1299 contains_cilk_spawn_stmt_walker (tree
*tp
, int *, void *)
1301 if (TREE_CODE (*tp
) == CILK_SPAWN_STMT
)
1307 /* Returns true if EXPR or any of its subtrees contain CILK_SPAWN_STMT
1311 contains_cilk_spawn_stmt (tree expr
)
1313 return walk_tree (&expr
, contains_cilk_spawn_stmt_walker
, NULL
, NULL
)