diff --git gcc/ChangeLog.cilkplus gcc/ChangeLog.cilkplus old mode 100644 new mode 100755 index 97975d8..0cae431 --- gcc/ChangeLog.cilkplus +++ gcc/ChangeLog.cilkplus @@ -1,3 +1,22 @@ +2013-02-04 Balaji V. Iyer + + * cilk.c (cilk_init_builtins): Defined __cilkrts_rethrow builtin + function. + (build_cilk_sync): Added code to set exception flag and exception data + in the stack frame. Also added code to call __cilkrts_rethrow function. + Finally, inserted this code in the appropriate location of if-stmt. + (set_cilk_except_flag): New function. + (clear_cilk_except_flag): Likewise. + (set_cilk_except_data): Likewise. + (build_cilk_catch_sync): Likewise. + * cilk-builtins.def (BUILT_IN_CILK_RETHROW): New builtin function. + * c/c-objc-common.h (LANG_HOOKS_FRAME_CLEANUP): Set this hook to + c_install_body_with_frame_cleanup. + * langhooks-def.h (LANG_HOOKS_FRAME_CLEANUP): New #define. + (lhd_install_body_with_frame_cleanup): New function. + * langhooks.h (lang_hooks_for_cilkplus): New struct field called + "install_body_with_frame_cleanup." + 2013-01-24 Balaji V. Iyer * cgraphunit.c (cgraph_finalize_function): If cilkplus is enabled and diff --git gcc/builtins.def gcc/builtins.def old mode 100644 new mode 100755 diff --git gcc/c-family/ChangeLog.cilkplus gcc/c-family/ChangeLog.cilkplus old mode 100644 new mode 100755 index 9a720b8..8bc0a17 --- gcc/c-family/ChangeLog.cilkplus +++ gcc/c-family/ChangeLog.cilkplus @@ -1,3 +1,11 @@ +2013-02-04 Balaji V. Iyer + + * c-cilk.c (build_cilk_wrapper_body): Replaced the function call for + install_body_with_frame_cleanup with the one from langhooks. + (build_cilk_for_body): Likewise. + (install_body_with_frame_cleanup): Renamed this function to + c_install_body_with_frame_cleanup. + 2013-01-24 Balaji V. Iyer * c-cpp-elem-function.c (elem_fn_create_fn): Set the assembler name and diff --git gcc/c-family/c-cilk.c gcc/c-family/c-cilk.c old mode 100644 new mode 100755 index f1bace5..dee4579 --- gcc/c-family/c-cilk.c +++ gcc/c-family/c-cilk.c @@ -99,7 +99,6 @@ static void cilk_outline (tree inner_fn, tree *, struct wrapper_data *); static tree copy_decl_for_cilk (tree decl, copy_body_data *id); static tree check_outlined_calls (tree *, int *, void *); static tree build_cilk_wrapper (tree, tree *); -static void install_body_with_frame_cleanup (tree, tree); static bool var_mentioned_p (tree exp, tree var); extern tree build_unary_op (location_t location, enum tree_code code, @@ -135,7 +134,6 @@ call_graph_add_fn (tree fndecl, struct wrapper_data *wd) tree_cons (NULL_TREE, fndecl, cilk_trees[CILK_TI_PENDING_FUNCTIONS]); f->curr_properties = cfun->curr_properties; - gcc_assert (cfun == DECL_STRUCT_FUNCTION (outer)); gcc_assert (cfun->decl == outer); @@ -1407,7 +1405,7 @@ build_cilk_wrapper_body (tree stmt, cilk_outline (fndecl, &stmt, wd); stmt = fold_build_cleanup_point_expr (void_type_node, stmt); gcc_assert (!DECL_SAVED_TREE (fndecl)); - install_body_with_frame_cleanup (fndecl, stmt); + lang_hooks.cilkplus.install_body_with_frame_cleanup (fndecl, stmt); gcc_assert (DECL_SAVED_TREE (fndecl)); pop_cfun_to (outer); @@ -1553,8 +1551,8 @@ check_outlined_calls (tree *tp, /* This function installs the internal functions of spawn helper and parent. */ -static void -install_body_with_frame_cleanup (tree fndecl, tree body) +void +c_install_body_with_frame_cleanup (tree fndecl, tree body) { tree list; tree frame = make_cilk_frame (fndecl); @@ -2455,7 +2453,7 @@ build_cilk_for_body (struct cilk_for_desc *cfd) body = build3 (BIND_EXPR, void_type_node, loop_var, body, block); TREE_CHAIN (loop_var) = cfd->var2; if (contains_spawn (body)) - install_body_with_frame_cleanup (fndecl, body); + lang_hooks.cilkplus.install_body_with_frame_cleanup (fndecl, body); else DECL_SAVED_TREE (fndecl) = body; diff --git gcc/c/c-objc-common.h gcc/c/c-objc-common.h index 8053c53..08ad087 100644 --- gcc/c/c-objc-common.h +++ gcc/c/c-objc-common.h @@ -122,4 +122,8 @@ along with GCC; see the file COPYING3. If not see #undef LANG_HOOKS_CILK_CHECK_CTRL_FLOW #define LANG_HOOKS_CILK_CHECK_CTRL_FLOW cilk_check_ctrl_flow + +#undef LANG_HOOKS_FRAME_CLEANUP +#define LANG_HOOKS_FRAME_CLEANUP c_install_body_with_frame_cleanup + #endif /* GCC_C_OBJC_COMMON */ diff --git gcc/cilk-builtins.def gcc/cilk-builtins.def old mode 100644 new mode 100755 index 5de740a..e483dd8 --- gcc/cilk-builtins.def +++ gcc/cilk-builtins.def @@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see DEF_CILK_BUILTIN_STUB (BUILT_IN_CILK_WORKER_ID, "__cilkrts_current_worker_id") DEF_CILK_BUILTIN_STUB (BUILT_IN_CILK_WORKER_PTR, "__cilkrts_current_worker") DEF_CILK_BUILTIN_STUB (BUILT_IN_CILK_DETACH, "__cilkrts_detach") +DEF_CILK_BUILTIN_STUB (BUILT_IN_CILK_RETHROW, "__cilkrts_rethrow") DEF_CILK_BUILTIN_STUB (BUILT_IN_CILK_SYNCHED, "__cilkrts_synched") DEF_CILK_BUILTIN_STUB (BUILT_IN_CILK_STOLEN, "__cilkrts_was_stolen") DEF_CILK_BUILTIN_STUB (BUILT_IN_CILK_ENTER_FRAME, "__cilkrts_enter_frame") diff --git gcc/cilk.c gcc/cilk.c old mode 100644 new mode 100755 index 7387c4c..c444025 --- gcc/cilk.c +++ gcc/cilk.c @@ -282,7 +282,10 @@ cilk_init_builtins (void) cilk_pop_fndecl = install_builtin ("__cilkrts_pop_frame", fptr_fun, BUILT_IN_CILK_POP_FRAME, false); - + + cilk_rethrow_fndecl = install_builtin ("__cilkrts_rethrow", fptr_fun, + BUILT_IN_CILK_RETHROW, false); + cilk_leave_fndecl = build_fn_decl ("__cilkrts_leave_frame", fptr_fun); mark_cold (cilk_leave_fndecl); cilk_leave_fndecl = lang_hooks.decls.pushdecl (cilk_leave_fndecl); @@ -701,7 +704,7 @@ make_cilk_frame (tree fn) return decl; } -/*This function will expand a cilk_sync call. */ +/* This function will expand a cilk_sync call. */ tree build_cilk_sync (void) @@ -714,15 +717,17 @@ build_cilk_sync (void) tree setjmp_expr; tree sync_list, frame_addr; tree sync_begin, sync_end; + tree except_flag, except_cond; /* Cilk_sync becomes the following code: if (frame.flags & CILK_FRAME_UNSYNCHED) if (!builtin_setjmp (frame.ctx) - // cilk_enter_begin(); + // cilk_sync_begin(); __cilkrts_sync(&frame); - // cilk_enter_end(); + // cilk_sync_end(); else - ; + if (sf.flags & CILK_FRAME_EXCEPTING) + __cilkrts_rethrow (&sf); else ; */ @@ -736,14 +741,27 @@ build_cilk_sync (void) build_int_cst (TREE_TYPE (unsynched), 0)); frame_addr = build1 (ADDR_EXPR, cilk_frame_ptr_type_decl, frame); + + /* Check if exception (0x10) bit is set in the sf->flags. */ + except_flag = fold_build2 (BIT_AND_EXPR, TREE_TYPE (flags), flags, + build_int_cst (TREE_TYPE (flags), + CILK_FRAME_EXCEPTING)); + except_flag = fold_build2 (NE_EXPR, TREE_TYPE (except_flag), except_flag, + build_int_cst (TREE_TYPE (except_flag), 0)); + + /* If the exception flag is set then call the __cilkrts_rethrow (&sf). */ + except_cond = fold_build3 (COND_EXPR, void_type_node, except_flag, + build_call_expr (cilk_rethrow_fndecl, 1, + frame_addr), + build_empty_stmt (EXPR_LOCATION (unsynched))); + sync_expr = build_call_expr (cilk_sync_fndecl, 1, frame_addr); setjmp_expr = cilk_call_setjmp (frame); setjmp_expr = fold_build2 (EQ_EXPR, TREE_TYPE (setjmp_expr), setjmp_expr, build_int_cst (TREE_TYPE (setjmp_expr), 0)); setjmp_expr = fold_build3 (COND_EXPR, void_type_node, setjmp_expr, - sync_expr, - build_empty_stmt (EXPR_LOCATION (unsynched))); + sync_expr, except_cond); sync = fold_build3 (COND_EXPR, void_type_node, unsynched, setjmp_expr, build_empty_stmt (EXPR_LOCATION (unsynched))); @@ -1563,3 +1581,132 @@ cilk_check_ctrl_flow (tree *fnbody) walk_tree (fnbody, check_gotos_outside_cilk_for, (void *) &label_list, NULL); return; } + +/* Sets the EXCEPTION bit (0x10) in the FRAME.flags field. */ + +tree +set_cilk_except_flag (tree frame) +{ + tree flags = dot (frame, CILK_TI_FRAME_FLAGS, 0); + + flags = build2 (MODIFY_EXPR, void_type_node, flags, + build2 (BIT_IOR_EXPR, TREE_TYPE (flags), flags, + build_int_cst (TREE_TYPE (flags), + CILK_FRAME_EXCEPTING))); + return flags; +} + +/* Clears the EXCEPTION bit (0x10) in the FRAME.flags field. */ + +tree +clear_cilk_except_flag (tree frame) +{ + tree flags = dot (frame, CILK_TI_FRAME_FLAGS, 0); + + flags = build2 (MODIFY_EXPR, void_type_node, flags, + build2 (BIT_AND_EXPR, TREE_TYPE (flags), flags, + build_int_cst (TREE_TYPE (flags), + ~CILK_FRAME_EXCEPTING))); + return flags; +} + +/* Sets the frame.EXCEPT_DATA field to the head of the exception pointer. */ + +tree +set_cilk_except_data (tree frame) +{ + tree except_data = dot (frame, CILK_TI_FRAME_EXCEPTION, 0); + tree uresume_fn = builtin_decl_implicit (BUILT_IN_EH_POINTER); + tree ret_expr; + uresume_fn = build_call_expr (uresume_fn, 1, + build_int_cst (integer_type_node, 0)); + ret_expr = build2 (MODIFY_EXPR, void_type_node, except_data, uresume_fn); + return ret_expr; +} + +/* This function will insert the code for a _Cilk_sync with the exception + related flags and fields set. This is created seperate because C does not + have exceptions and setting and checking these fields could trigger + seg-faults. */ + +tree +build_cilk_catch_sync (void) +{ + tree frame = cfun->cilk_frame_decl; + tree flags; + tree unsynched; + tree sync; + tree sync_expr; + tree setjmp_expr; + tree sync_list, frame_addr; + tree sync_begin, sync_end; + tree set_except_flag, except_data, sync_expr_list; + tree clear_except_flag, clear_except_cond_list; + + /* We insert the following code: + + if (frame.flags & CILK_FRAME_UNSYNCHED) + { + if (!builtin_setjmp (frame.ctx) + { + frame.except_data = __builtin_eh_pointer(0); + frame.flags |= CILK_FRAME_EXCEPTING; + // cilk_sync_begin(); + __cilkrts_sync(&frame); + // cilk_sync_end(); + } + else + frame.flags &= ~CILK_FRAME_EXCEPTING. + } + */ + flags = dot (frame, CILK_TI_FRAME_FLAGS, false); + + unsynched = fold_build2 (BIT_AND_EXPR, TREE_TYPE (flags), flags, + build_int_cst (TREE_TYPE (flags), + CILK_FRAME_UNSYNCHED)); + + unsynched = fold_build2 (NE_EXPR, TREE_TYPE (unsynched), unsynched, + build_int_cst (TREE_TYPE (unsynched), 0)); + + frame_addr = build1 (ADDR_EXPR, cilk_frame_ptr_type_decl, frame); + + sync_expr_list = alloc_stmt_list (); + sync_expr = build_call_expr (cilk_sync_fndecl, 1, frame_addr); + + /* Sets the sf->except_data = __builtin_eh_pointer (0); */ + except_data = set_cilk_except_data (frame); + + /* Sets sf->flags to sf->flags | CILK_FRAME_EXCEPTING. */ + set_except_flag = set_cilk_except_flag (frame); + append_to_statement_list (sync_expr, &sync_expr_list); + append_to_statement_list (except_data, &sync_expr_list); + append_to_statement_list (set_except_flag, &sync_expr_list); + + clear_except_cond_list = alloc_stmt_list (); + + /* Sets sf->flags to sf->flags & ~CILK_FRAME_EXCEPTING. */ + clear_except_flag = clear_cilk_except_flag (frame); + append_to_statement_list (clear_except_flag, &clear_except_cond_list); + + setjmp_expr = cilk_call_setjmp (frame); + + setjmp_expr = fold_build2 (EQ_EXPR, TREE_TYPE (setjmp_expr), setjmp_expr, + build_int_cst (TREE_TYPE (setjmp_expr), 0)); + + /* Checks of __builtin_setjmp (frame.ctx) == 0. IF so, then we jump to + sync_list otherwise, we just jump to the clear_except_cond_list. */ + setjmp_expr = fold_build3 (COND_EXPR, void_type_node, setjmp_expr, + sync_expr_list, clear_except_cond_list); + + sync = fold_build3 (COND_EXPR, void_type_node, unsynched, setjmp_expr, + build_empty_stmt (EXPR_LOCATION (unsynched))); + + sync_begin = build_call_expr (cilk_sync_begin_fndecl, 1, frame_addr); + sync_end = build_call_expr (cilk_sync_end_fndecl, 1, frame_addr); + sync_list = alloc_stmt_list (); + append_to_statement_list_force (sync_begin, &sync_list); + append_to_statement_list_force (sync, &sync_list); + append_to_statement_list_force (sync_end, &sync_list); + + return sync_list; +} diff --git gcc/cilk.h gcc/cilk.h old mode 100644 new mode 100755 index 275b8b8..41ec273 --- gcc/cilk.h +++ gcc/cilk.h @@ -323,5 +323,10 @@ extern bool is_cilk_must_expand_fn (enum built_in_function); extern bool is_elem_fn_attribute_p (tree); extern bool is_cilk_function_decl (tree, tree); extern void clear_pragma_simd_list (void); +extern tree set_cilk_except_flag (tree); +extern tree clear_cilk_except_flag (tree); +extern tree set_cilk_except_data (tree); +extern void c_install_body_with_frame_cleanup (tree, tree); +tree build_cilk_catch_sync (void); #endif /* GCC_CILK_H */ diff --git gcc/cp/ChangeLog.cilkplus gcc/cp/ChangeLog.cilkplus old mode 100644 new mode 100755 index 9de4d57..b86af85 --- gcc/cp/ChangeLog.cilkplus +++ gcc/cp/ChangeLog.cilkplus @@ -1,3 +1,13 @@ +2013-02-04 Balaji V. Iyer + + * cp-cilk.c (insert_sync_stmt_after_catch): New function. + (cp_install_body_with_frame_cleanup): Likewise. + (cp_make_cilk_frame): called walk_tree with insert_sync_stmt_after_catch + as a function call parameter. + * cp-objcp-common.h (LANG_HOOKS_FRAME_CLEANUP): New define. + * except.c (do_begin_catch): Made this routine non-static. + (do_end_catch): Likewise. + 2013-01-09 Balaji V. Iyer * semantics.c (finish_call_expr): Added a check for lambda expression diff --git gcc/cp/cp-cilk.c gcc/cp/cp-cilk.c old mode 100644 new mode 100755 index 9df24ce..9a18180 --- gcc/cp/cp-cilk.c +++ gcc/cp/cp-cilk.c @@ -131,6 +131,7 @@ struct cilk_for_desc struct pointer_map_t *decl_map; }; +void cp_install_body_with_frame_cleanup (tree fndecl, tree body); void gimplify_cilk_for_stmt (tree *for_p, gimple_seq *pre_p); static tree compute_loop_var (struct cilk_for_desc *, tree, tree); static bool cp_extract_for_fields (struct cilk_for_desc *cfd, tree for_stmt); @@ -815,6 +816,32 @@ in_cilk_block (void) /* This function will insert a _Cilk_sync right before a try block. */ static tree +insert_sync_before_catch (tree *tp, int *walk_subtrees, + void *data ATTRIBUTE_UNUSED) +{ + tree new_sync_stmt = NULL_TREE, synced_stmt_list = NULL_TREE; + + synced_stmt_list = alloc_stmt_list (); + if (TREE_CODE (*tp) == HANDLER) + { + new_sync_stmt = build_cilk_catch_sync (); + gcc_assert (new_sync_stmt && new_sync_stmt != error_mark_node); + append_to_statement_list_force (new_sync_stmt, &synced_stmt_list); + append_to_statement_list_force (HANDLER_BODY (*tp), &synced_stmt_list); + HANDLER_BODY (*tp) = synced_stmt_list; + + /* We don't need to go any deeper. */ + *walk_subtrees = 0; + + /* We are finished here. We only need to find the first catch block. */ + return *tp; + } + return NULL; +} + +/* This function will insert a _Cilk_sync right before a try block. */ + +static tree insert_sync_stmt (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) { tree new_sync_stmt = NULL_TREE, synced_stmt_list = NULL_TREE; @@ -895,6 +922,7 @@ cp_make_cilk_frame (tree compstmt) /* Here we talk through all the subtrees of compstmt and as soon as we find a try block, we insert a _Cilk_sync right before it. */ cp_walk_tree (&compstmt, insert_sync_stmt, NULL, NULL); + cp_walk_tree (&compstmt, insert_sync_before_catch, NULL, NULL); } return decl; @@ -2898,3 +2926,41 @@ cilk_lambda_fn_temp (tree lambda_fn) add_local_decl (cfun, return_var); return return_var; } + +/* This function installs the internal functions of spawn helper and parent. */ + +void +cp_install_body_with_frame_cleanup (tree fndecl, tree body) +{ + tree list, catch_tf_expr; + tree try_catch_expr, catch_list, try_finally_expr, except_flag, except_data; + tree frame = make_cilk_frame (fndecl); + tree dtor = build_cilk_function_exit (frame, false, false); + extern tree do_begin_catch (void); + extern tree do_end_catch (tree); + add_local_decl (cfun, frame); + + DECL_SAVED_TREE (fndecl) = (list = alloc_stmt_list ()); + + catch_list = alloc_stmt_list (); + except_flag = set_cilk_except_flag (frame); + except_data = set_cilk_except_data (frame); + append_to_statement_list (except_flag, &catch_list); + append_to_statement_list (except_data, &catch_list); + append_to_statement_list (do_begin_catch (), &catch_list); + append_to_statement_list (build_throw (NULL_TREE), &catch_list); + #if 1 + append_to_statement_list (build_cilk_function_exit (frame, false, false), + &catch_list); + #endif + catch_tf_expr = build_stmt (EXPR_LOCATION (body), TRY_FINALLY_EXPR, + catch_list, do_end_catch (NULL_TREE)); + catch_list = build2 (CATCH_EXPR, void_type_node, NULL_TREE, catch_tf_expr); + + try_catch_expr = build_stmt (EXPR_LOCATION (body), TRY_CATCH_EXPR, body, + catch_list); + try_finally_expr = build_stmt (EXPR_LOCATION (body), TRY_FINALLY_EXPR, + try_catch_expr, dtor); + append_to_statement_list_force (try_finally_expr, &list); +} + diff --git gcc/cp/cp-objcp-common.h gcc/cp/cp-objcp-common.h index bcd42d9..4b96b43 100644 --- gcc/cp/cp-objcp-common.h +++ gcc/cp/cp-objcp-common.h @@ -166,4 +166,8 @@ extern void cp_common_init_ts (void); #undef LANG_HOOKS_ELEM_FN_CREATE_FN #define LANG_HOOKS_ELEM_FN_CREATE_FN elem_fn_create_fn + +#undef LANG_HOOKS_FRAME_CLEANUP +#define LANG_HOOKS_FRAME_CLEANUP cp_install_body_with_frame_cleanup + #endif /* GCC_CP_OBJCP_COMMON */ diff --git gcc/cp/cp-tree.h gcc/cp/cp-tree.h old mode 100644 new mode 100755 index 26e8c0f..031bb43 --- gcc/cp/cp-tree.h +++ gcc/cp/cp-tree.h @@ -6107,6 +6107,7 @@ extern void warn_unimplemented_cilk (bool fatal); extern void build_cilk_types (void); extern void cilk_gimplify_for_stmt (tree *, tree *); extern void gimplify_cilk_for_stmt (tree *, gimple_seq *); +extern void cp_install_body_with_frame_cleanup (tree, tree); extern tree build_cilk_run (tree); extern bool cilk_valid_spawn (tree); extern void cilk_init_frame_descriptor (struct function *, bool); diff --git gcc/cp/except.c gcc/cp/except.c index 16a7c45..9a5b64a 100644 --- gcc/cp/except.c +++ gcc/cp/except.c @@ -35,9 +35,9 @@ along with GCC; see the file COPYING3. If not see static void push_eh_cleanup (tree); static tree prepare_eh_type (tree); -static tree do_begin_catch (void); +tree do_begin_catch (void); static int dtor_nothrow (tree); -static tree do_end_catch (tree); +tree do_end_catch (tree); static bool decl_is_java_type (tree decl, int err); static void initialize_handler_parm (tree, tree); static tree do_allocate_exception (tree); @@ -182,7 +182,7 @@ do_get_exception_ptr (void) /* Build up a call to __cxa_begin_catch, to tell the runtime that the exception has been handled. */ -static tree +tree do_begin_catch (void) { tree fn; @@ -230,7 +230,7 @@ dtor_nothrow (tree type) /* Build up a call to __cxa_end_catch, to destroy the exception object for the current catch block if no others are currently using it. */ -static tree +tree do_end_catch (tree type) { tree fn, cleanup; diff --git gcc/langhooks-def.h gcc/langhooks-def.h old mode 100644 new mode 100755 index 8c0af7f..3085a02 --- gcc/langhooks-def.h +++ gcc/langhooks-def.h @@ -217,9 +217,11 @@ void lhd_gimplify_cilk_for (tree *, gimple_seq *, gimple_seq *); void lhd_gimplify_cilk_sync (tree *, gimple_seq *); void lhd_elem_fn_create_fn (tree); void lhd_cilk_check_ctrl_flow (tree *); +void lhd_install_body_with_frame_cleanup (tree, tree); #define LANG_HOOKS_CILK_RECOGNIZE_SPAWN hook_bool_tree_false #define LANG_HOOKS_CILK_VALID_CTOR hook_bool_tree_false #define LANG_HOOKS_CILK_VALID_SPAWN lhd_cilk_valid_spawn +#define LANG_HOOKS_FRAME_CLEANUP lhd_install_body_with_frame_cleanup #define LANG_HOOKS_GIMPLIFY_CILK_SPAWN lhd_gimplify_cilk_spawn #define LANG_HOOKS_GIMPLIFY_CILK_FOR lhd_gimplify_cilk_for #define LANG_HOOKS_GIMPLIFY_CILK_SYNC lhd_gimplify_cilk_sync @@ -229,7 +231,8 @@ void lhd_cilk_check_ctrl_flow (tree *); LANG_HOOKS_CILK_RECOGNIZE_SPAWN, \ LANG_HOOKS_CILK_VALID_CTOR, \ LANG_HOOKS_CILK_VALID_SPAWN, \ - LANG_HOOKS_GIMPLIFY_CILK_SPAWN, \ + LANG_HOOKS_FRAME_CLEANUP, \ + LANG_HOOKS_GIMPLIFY_CILK_SPAWN, \ LANG_HOOKS_GIMPLIFY_CILK_FOR, \ LANG_HOOKS_GIMPLIFY_CILK_SYNC, \ LANG_HOOKS_CILK_CHECK_CTRL_FLOW, \ diff --git gcc/langhooks.c gcc/langhooks.c old mode 100644 new mode 100755 index bcd4284..1e53465 --- gcc/langhooks.c +++ gcc/langhooks.c @@ -730,7 +730,17 @@ lhd_elem_fn_create_fn (tree x ATTRIBUTE_UNUSED) return; } -void lhd_cilk_check_ctrl_flow (tree *x ATTRIBUTE_UNUSED) +void +lhd_cilk_check_ctrl_flow (tree *x ATTRIBUTE_UNUSED) +{ + return; +} + +/* Empty function for install that will cleanup the frame in spawn helper. */ + +void +lhd_install_body_with_frame_cleanup (tree x ATTRIBUTE_UNUSED, + tree y ATTRIBUTE_UNUSED) { return; } diff --git gcc/langhooks.h gcc/langhooks.h old mode 100644 new mode 100755 index 76c0975..c375596 --- gcc/langhooks.h +++ gcc/langhooks.h @@ -231,6 +231,7 @@ struct lang_hooks_for_cilkplus bool (*recognize_spawn) (tree); bool (*spawnable_constructor) (tree); bool (*cilk_valid_spawn) (tree); + void (*install_body_with_frame_cleanup) (tree, tree); void (*gimplify_cilk_spawn) (tree *, gimple_seq *, gimple_seq *); void (*gimplify_cilk_for) (tree *, gimple_seq *, gimple_seq *); void (*gimplify_cilk_sync) (tree *, gimple_seq *); diff --git gcc/testsuite/ChangeLog.cilkplus gcc/testsuite/ChangeLog.cilkplus old mode 100644 new mode 100755 index 47b85ba..ac965b9 --- gcc/testsuite/ChangeLog.cilkplus +++ gcc/testsuite/ChangeLog.cilkplus @@ -1,3 +1,7 @@ +2013-02-04 Balaji V. Iyer + + * g++.dg/cilk-plus/cilk_keywords_test/execute/catch_exc.cc: New test. + 2013-01-22 Balaji V. Iyer * gcc.dg/cilk-plus/cilk_keywords_test/errors/grainsize_error1.c: New diff --git gcc/testsuite/g++.dg/cilk-plus/cilk_keywords_test/execute/catch_exc.cc gcc/testsuite/g++.dg/cilk-plus/cilk_keywords_test/execute/catch_exc.cc new file mode 100755 index 0000000..c48d89b --- /dev/null +++ gcc/testsuite/g++.dg/cilk-plus/cilk_keywords_test/execute/catch_exc.cc @@ -0,0 +1,63 @@ +#include +#include +#if HAVE_IO +#include +#include +#endif +#include + + +void func(int volatile* steal_me) +{ + while (! (*steal_me)) + { + usleep(2000); + } +#if HAVE_IO + printf("Foo executing on %d\n", __cilkrts_get_worker_number()); +#endif + throw 5; +} + +void my_test() +{ + volatile int steal_me = 0; + + try + { + _Cilk_spawn func(&steal_me); +#if HAVE_IO + printf("Continuation executing on %d\n", + __cilkrts_get_worker_number()); +#endif + steal_me = 1; + _Cilk_sync; + goto bad; + } + + catch (int x) + { +#if HAVE_IO + printf("We caught x = %d\n", x); +#endif + assert(x == 5); + } + if (0) + { + bad: +#if HAVE_IO + printf("We should not be here!\n"); +#endif + assert(0); + } +} + + +int main() +{ + my_test(); +#if HAVE_IO + printf("PASSED\n"); +#endif + return 0; +}