+2014-01-24 Balaji V. Iyer <balaji.v.iyer@intel.com>
+
+ * builtins.c (is_builtin_name): Renamed flag_enable_cilkplus to
+ flag_cilkplus.
+ * builtins.def: Likewise.
+ * cilk.h (fn_contains_cilk_spawn_p): Likewise.
+ * cppbuiltin.c (define_builtin_macros_for_compilation_flags): Likewise.
+ * ira.c (ira_setup_eliminable_regset): Likewise.
+ * omp-low.c (gate_expand_omp): Likewise.
+ (execute_lower_omp): Likewise.
+ (diagnose_sb_0): Likewise.
+ (gate_diagnose_omp_blocks): Likewise.
+ (simd_clone_clauses_extract): Likewise.
+ (gate): Likewise.
+
2014-01-24 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
* config/rs6000/rs6000.c (rs6000_expand_vec_perm_const_1): Remove
return true;
if (strncmp (name, "__atomic_", 9) == 0)
return true;
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& (!strcmp (name, "__cilkrts_detach")
|| !strcmp (name, "__cilkrts_pop_frame")))
return true;
#undef DEF_CILKPLUS_BUILTIN
#define DEF_CILKPLUS_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_FN_INT_VAR, BT_LAST, \
- false, false, false, ATTRS, false, flag_enable_cilkplus)
+ false, false, false, ATTRS, false, flag_cilkplus)
/* Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
+2014-01-24 Balaji V. Iyer <balaji.v.iyer@intel.com>
+
+ * c-common.c (c_define_builtins): Replaced flag_enable_cilkplus with
+ flag_cilkplus.
+ * c-pragma.c (init_pragma): Likewise.
+ * c.opt: Likewise.
+
2014-01-23 Marek Polacek <polacek@redhat.com>
PR c/59846
build_common_builtin_nodes ();
- if (flag_enable_cilkplus)
+ if (flag_cilkplus)
cilk_init_builtins ();
}
omp_pragmas_simd[i].id, true, true);
}
- if (flag_enable_cilkplus && !flag_preprocess_only)
+ if (flag_cilkplus && !flag_preprocess_only)
cpp_register_deferred_pragma (parse_in, NULL, "simd", PRAGMA_CILK_SIMD,
true, false);
Where shorter, use canonicalized paths to systems headers.
fcilkplus
-C ObjC C++ ObjC++ LTO Report Var(flag_enable_cilkplus) Init(0)
+C ObjC C++ ObjC++ LTO Report Var(flag_cilkplus) Init(0)
Enable Cilk Plus
fcond-mismatch
+2014-01-24 Balaji V. Iyer <balaji.v.iyer@intel.com>
+
+ * c-parser.c (c_parser_declaration_or_fndef): Replaced
+ flag_enable_cilkplus with flag_cilkplus.
+ (c_parser_direct_declarator_inner): Likewise.
+ (c_parser_attribute_any_word): Likewise.
+ (c_parser_attributes): Likewise.
+ (c_parser_compound_statement): Likewise.
+ (c_parser_statement_after_labels): Likewise.
+ (c_parser_if_statement): Likewise.
+ (c_parser_switch_statement): Likewise.
+ (c_parser_do_statement): Likewise.
+ (c_parser_for_statement): Likewise.
+ (c_parser_unary_expression): Likewise.
+ (c_parser_postfix_expression): Likewise.
+ (c_parser_postfix_expression_after_primary): Likewise.
+ (c_parser_postfix_expression_after_primary): Likewise.
+ (c_parser_omp_clause_name): Likewise.
+ (c_finish_omp_declare_simd): Likewise.
+ (c_parser_cilk_verify_simd): Likewise.
+ * c-typeck.c (build_array_ref): Likewise.
+ (build_function_call_vec): Likewise.
+ (convert_arguments): Likewise.
+ (build_compound_expr): Likewise.
+ (c_finish_return): Likewise.
+ (c_finish_if_stmt): Likewise.
+ (c_finish_loop): Likewise.
+ (build_binary_op): Likewise.
+
2014-01-23 Marek Polacek <polacek@redhat.com>
PR c/59846
DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus
= c_parser_peek_token (parser)->location;
fnbody = c_parser_compound_statement (parser);
- if (flag_enable_cilkplus && contains_array_notation_expr (fnbody))
+ if (flag_cilkplus && contains_array_notation_expr (fnbody))
fnbody = expand_array_notation_exprs (fnbody);
if (nested)
{
dimen.value = NULL_TREE;
star_seen = false;
}
- else if (flag_enable_cilkplus
+ else if (flag_cilkplus
&& c_parser_next_token_is (parser, CPP_COLON))
{
dimen.value = error_mark_node;
}
if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
c_parser_consume_token (parser);
- else if (flag_enable_cilkplus
+ else if (flag_cilkplus
&& c_parser_next_token_is (parser, CPP_COLON))
{
error_at (c_parser_peek_token (parser)->location,
static inline bool
is_cilkplus_vector_p (tree name)
{
- if (flag_enable_cilkplus && is_attribute_p ("vector", name))
+ if (flag_cilkplus && is_attribute_p ("vector", name))
return true;
return false;
}
parser->lex_untranslated_string = false;
}
- if (flag_enable_cilkplus && !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
+ if (flag_cilkplus && !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
c_finish_cilk_simd_fn_tokens (parser);
return attrs;
}
c_parser_compound_statement_nostart (parser);
/* If the compound stmt contains array notations, then we expand them. */
- if (flag_enable_cilkplus && contains_array_notation_expr (stmt))
+ if (flag_cilkplus && contains_array_notation_expr (stmt))
stmt = expand_array_notation_exprs (stmt);
return c_end_compound_stmt (brace_loc, stmt, true);
}
case RID_CILK_SYNC:
c_parser_consume_token (parser);
c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
- if (!flag_enable_cilkplus)
+ if (!flag_cilkplus)
error_at (loc, "-fcilkplus must be enabled to use %<_Cilk_sync%>");
else
add_stmt (build_cilk_sync ());
if_stmt = c_end_compound_stmt (loc, block, flag_isoc99);
/* If the if statement contains array notations, then we expand them. */
- if (flag_enable_cilkplus && contains_array_notation_expr (if_stmt))
+ if (flag_cilkplus && contains_array_notation_expr (if_stmt))
if_stmt = fix_conditional_array_notations (if_stmt);
add_stmt (if_stmt);
}
ce = c_parser_expression (parser);
ce = convert_lvalue_to_rvalue (switch_cond_loc, ce, true, false);
expr = ce.value;
- if (flag_enable_cilkplus && contains_array_notation_expr (expr))
+ if (flag_cilkplus && contains_array_notation_expr (expr))
{
error_at (switch_cond_loc,
"array notations cannot be used as a condition for switch "
block = c_begin_compound_stmt (flag_isoc99);
loc = c_parser_peek_token (parser)->location;
cond = c_parser_paren_condition (parser);
- if (flag_enable_cilkplus && contains_array_notation_expr (cond))
+ if (flag_cilkplus && contains_array_notation_expr (cond))
{
error_at (loc, "array notations cannot be used as a condition for while "
"statement");
new_cont = c_cont_label;
c_cont_label = save_cont;
cond = c_parser_paren_condition (parser);
- if (flag_enable_cilkplus && contains_array_notation_expr (cond))
+ if (flag_cilkplus && contains_array_notation_expr (cond))
{
error_at (loc, "array notations cannot be used as a condition for a "
"do-while statement");
else
{
cond = c_parser_condition (parser);
- if (flag_enable_cilkplus && contains_array_notation_expr (cond))
+ if (flag_cilkplus && contains_array_notation_expr (cond))
{
error_at (loc, "array notations cannot be used in a "
"condition for a for-loop");
op = c_parser_cast_expression (parser, NULL);
/* If there is array notations in op, we expand them. */
- if (flag_enable_cilkplus && TREE_CODE (op.value) == ARRAY_NOTATION_REF)
+ if (flag_cilkplus && TREE_CODE (op.value) == ARRAY_NOTATION_REF)
return fix_array_notation_expr (exp_loc, PREINCREMENT_EXPR, op);
else
{
op = c_parser_cast_expression (parser, NULL);
/* If there is array notations in op, we expand them. */
- if (flag_enable_cilkplus && TREE_CODE (op.value) == ARRAY_NOTATION_REF)
+ if (flag_cilkplus && TREE_CODE (op.value) == ARRAY_NOTATION_REF)
return fix_array_notation_expr (exp_loc, PREDECREMENT_EXPR, op);
else
{
break;
case RID_CILK_SPAWN:
c_parser_consume_token (parser);
- if (!flag_enable_cilkplus)
+ if (!flag_cilkplus)
{
error_at (loc, "-fcilkplus must be enabled to use "
"%<_Cilk_spawn%>");
case CPP_OPEN_SQUARE:
/* Array reference. */
c_parser_consume_token (parser);
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& c_parser_peek_token (parser)->type == CPP_COLON)
/* If we are here, then we have something like this:
Array [ : ]
For 2 and 3 we handle it like we handle array notations. The
idx value we have above becomes the initial/start index.
*/
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& c_parser_peek_token (parser)->type == CPP_COLON)
expr.value = c_parser_array_notation (expr_loc, parser, idx,
expr.value);
/* Postincrement. */
c_parser_consume_token (parser);
/* If the expressions have array notations, we expand them. */
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& TREE_CODE (expr.value) == ARRAY_NOTATION_REF)
expr = fix_array_notation_expr (expr_loc, POSTINCREMENT_EXPR, expr);
else
/* Postdecrement. */
c_parser_consume_token (parser);
/* If the expressions have array notations, we expand them. */
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& TREE_CODE (expr.value) == ARRAY_NOTATION_REF)
expr = fix_array_notation_expr (expr_loc, POSTDECREMENT_EXPR, expr);
else
result = PRAGMA_OMP_CLAUSE_MAP;
else if (!strcmp ("mergeable", p))
result = PRAGMA_OMP_CLAUSE_MERGEABLE;
- else if (flag_enable_cilkplus && !strcmp ("mask", p))
+ else if (flag_cilkplus && !strcmp ("mask", p))
result = PRAGMA_CILK_CLAUSE_MASK;
break;
case 'n':
result = PRAGMA_OMP_CLAUSE_NUM_TEAMS;
else if (!strcmp ("num_threads", p))
result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
- else if (flag_enable_cilkplus && !strcmp ("nomask", p))
+ else if (flag_cilkplus && !strcmp ("nomask", p))
result = PRAGMA_CILK_CLAUSE_NOMASK;
break;
case 'o':
result = PRAGMA_OMP_CLAUSE_UNTIED;
break;
case 'v':
- if (flag_enable_cilkplus && !strcmp ("vectorlength", p))
+ if (flag_cilkplus && !strcmp ("vectorlength", p))
result = PRAGMA_CILK_CLAUSE_VECTORLENGTH;
break;
}
c_finish_omp_declare_simd (c_parser *parser, tree fndecl, tree parms,
vec<c_token> clauses)
{
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& clauses.exists () && !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
{
error ("%<#pragma omp declare simd%> cannot be used in the same "
gcc_assert (parser->tokens == &parser->tokens_buf[0]);
bool is_cilkplus_cilk_simd_fn = false;
- if (flag_enable_cilkplus && !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
+ if (flag_cilkplus && !vec_safe_is_empty (parser->cilk_simd_fn_tokens))
{
parser->tokens = parser->cilk_simd_fn_tokens->address ();
parser->tokens_avail = vec_safe_length (parser->cilk_simd_fn_tokens);
c_parser_cilk_verify_simd (c_parser *parser,
enum pragma_context context)
{
- if (!flag_enable_cilkplus)
+ if (!flag_cilkplus)
{
warning (0, "pragma simd ignored because -fcilkplus is not enabled");
c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
|| TREE_TYPE (index) == error_mark_node)
return error_mark_node;
- if (flag_enable_cilkplus && contains_array_notation_expr (index))
+ if (flag_cilkplus && contains_array_notation_expr (index))
{
size_t rank = 0;
if (!find_rank (loc, index, index, true, &rank))
if (name && !strncmp (IDENTIFIER_POINTER (name), "__atomic_", 9))
origtypes = NULL;
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& is_cilkplus_reduce_builtin (function))
origtypes = NULL;
}
break;
}
}
- if (flag_enable_cilkplus && fundecl && is_cilkplus_reduce_builtin (fundecl))
+ if (flag_cilkplus && fundecl && is_cilkplus_reduce_builtin (fundecl))
return vec_safe_length (values);
/* Scan the given expressions and types, producing individual
tree eptype = NULL_TREE;
tree ret;
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& (TREE_CODE (expr1) == CILK_SPAWN_STMT
|| TREE_CODE (expr2) == CILK_SPAWN_STMT))
{
warning_at (loc, 0,
"function declared %<noreturn%> has a %<return%> statement");
- if (flag_enable_cilkplus && contains_array_notation_expr (retval))
+ if (flag_cilkplus && contains_array_notation_expr (retval))
{
/* Array notations are allowed in a return statement if it is inside a
built-in array notation reduction function. */
return error_mark_node;
}
}
- if (flag_enable_cilkplus && retval && TREE_CODE (retval) == CILK_SPAWN_STMT)
+ if (flag_cilkplus && retval && TREE_CODE (retval) == CILK_SPAWN_STMT)
{
error_at (loc, "use of %<_Cilk_spawn%> in a return statement is not "
"allowed");
else_block must be either 0 or be equal to the rank of the condition. If
the condition does not have array notations then break them up as it is
broken up in a normal expression. */
- if (flag_enable_cilkplus && contains_array_notation_expr (cond))
+ if (flag_cilkplus && contains_array_notation_expr (cond))
{
size_t then_rank = 0, cond_rank = 0, else_rank = 0;
if (!find_rank (if_locus, cond, cond, true, &cond_rank))
{
tree entry = NULL, exit = NULL, t;
- if (flag_enable_cilkplus && contains_array_notation_expr (cond))
+ if (flag_cilkplus && contains_array_notation_expr (cond))
{
error_at (start_locus, "array notation expression cannot be used in a "
"loop%'s condition");
/* When Cilk Plus is enabled and there are array notations inside op0, then
we check to see if there are builtin array notation functions. If
so, then we take on the type of the array notation inside it. */
- if (flag_enable_cilkplus && contains_array_notation_expr (op0))
+ if (flag_cilkplus && contains_array_notation_expr (op0))
orig_type0 = type0 = find_correct_array_notation_type (op0);
else
orig_type0 = type0 = TREE_TYPE (op0);
- if (flag_enable_cilkplus && contains_array_notation_expr (op1))
+ if (flag_cilkplus && contains_array_notation_expr (op1))
orig_type1 = type1 = find_correct_array_notation_type (op1);
else
orig_type1 = type1 = TREE_TYPE (op1);
inline bool
fn_contains_cilk_spawn_p (function *f)
{
- return (flag_enable_cilkplus
+ return (flag_cilkplus
&& (f->calls_cilk_spawn || f->cilk_frame_decl != NULL_TREE));
}
+2014-01-24 Balaji V. Iyer <balaji.v.iyer@intel.com>
+
+ * call.c (magic_varargs_p): Replaced flag_enable_cilkplus with
+ flag_cilkplus.
+ * cp-gimplify.c (cp_genericize): Likewise.
+ * decl.c (grokfndecl): Likewise.
+ * parser.c (cp_parser_postfix_expression): Likewise.
+ (cp_parser_postfix_open_square_expression): Likewise.
+ (cp_parser_direct_declarator): Likewise.
+ (is_cilkplus_vector_p): Likewise.
+ (cp_parser_omp_clause_name): Likewise.
+ (cp_parser_omp_all_clauses): Likewise.
+ * pt.c (apply_late_template_attributes): Likewise.
+ * typeck.c (cp_build_array_ref): Likewise.
+ (cp_build_compound_expr): Likewise.
+ (check_return_expr): Likewise.
+
2014-01-24 Jason Merrill <jason@redhat.com>
PR c++/58550
bool
magic_varargs_p (tree fn)
{
- if (flag_enable_cilkplus && is_cilkplus_reduce_builtin (fn) != BUILT_IN_NONE)
+ if (flag_cilkplus && is_cilkplus_reduce_builtin (fn) != BUILT_IN_NONE)
return true;
if (DECL_BUILT_IN (fn))
/* If it is a built-in array notation function, then the return type of
the function is the element type of the array passed in as array
notation (i.e. the first parameter of the function). */
- if (flag_enable_cilkplus && TREE_CODE (fn) == CALL_EXPR)
+ if (flag_cilkplus && TREE_CODE (fn) == CALL_EXPR)
{
enum built_in_function bif =
is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn));
return;
/* Expand all the array notations here. */
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& contains_array_notation_expr (DECL_SAVED_TREE (fndecl)))
DECL_SAVED_TREE (fndecl) =
expand_array_notation_exprs (DECL_SAVED_TREE (fndecl));
if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
TREE_NOTHROW (decl) = 1;
- if (flag_openmp || flag_enable_cilkplus)
+ if (flag_openmp || flag_cilkplus)
{
/* Adjust "omp declare simd" attributes. */
tree ods = lookup_attribute ("omp declare simd", *attrlist);
postfix_expression =
cp_parser_postfix_expression (parser, false, false,
false, false, &idk);
- if (!flag_enable_cilkplus)
+ if (!flag_cilkplus)
{
error_at (token->location, "-fcilkplus must be enabled to use"
" %<_Cilk_spawn%>");
}
case RID_CILK_SYNC:
- if (flag_enable_cilkplus)
+ if (flag_cilkplus)
{
tree sync_expr = build_cilk_sync ();
SET_EXPR_LOCATION (sync_expr,
bool expr_nonconst_p;
maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
index = cp_parser_braced_list (parser, &expr_nonconst_p);
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& cp_lexer_peek_token (parser->lexer)->type == CPP_COLON)
{
error_at (cp_lexer_peek_token (parser->lexer)->location,
return error_mark_node;
}
}
- else if (flag_enable_cilkplus)
+ else if (flag_cilkplus)
{
/* Here are have these two options:
ARRAY[EXP : EXP] - Array notation expr with default
/* In here, we handle cases where attribute is used after
the function declaration. For example:
void func (int x) __attribute__((vector(..))); */
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& cp_next_tokens_can_be_gnu_attribute_p (parser))
{
cp_parser_parse_tentatively (parser);
static inline bool
is_cilkplus_vector_p (tree name)
{
- if (flag_enable_cilkplus && is_attribute_p ("vector", name))
+ if (flag_cilkplus && is_attribute_p ("vector", name))
return true;
return false;
}
result = PRAGMA_OMP_CLAUSE_MAP;
else if (!strcmp ("mergeable", p))
result = PRAGMA_OMP_CLAUSE_MERGEABLE;
- else if (flag_enable_cilkplus && !strcmp ("mask", p))
+ else if (flag_cilkplus && !strcmp ("mask", p))
result = PRAGMA_CILK_CLAUSE_MASK;
break;
case 'n':
result = PRAGMA_OMP_CLAUSE_NOTINBRANCH;
else if (!strcmp ("nowait", p))
result = PRAGMA_OMP_CLAUSE_NOWAIT;
- else if (flag_enable_cilkplus && !strcmp ("nomask", p))
+ else if (flag_cilkplus && !strcmp ("nomask", p))
result = PRAGMA_CILK_CLAUSE_NOMASK;
else if (!strcmp ("num_teams", p))
result = PRAGMA_OMP_CLAUSE_NUM_TEAMS;
result = PRAGMA_OMP_CLAUSE_UNTIED;
break;
case 'v':
- if (flag_enable_cilkplus && !strcmp ("vectorlength", p))
+ if (flag_cilkplus && !strcmp ("vectorlength", p))
result = PRAGMA_CILK_CLAUSE_VECTORLENGTH;
break;
}
saw_error:
/* In Cilk Plus SIMD enabled functions there is no pragma_token, so
no reason to skip to the end. */
- if (!(flag_enable_cilkplus && pragma_tok == NULL))
+ if (!(flag_cilkplus && pragma_tok == NULL))
cp_parser_skip_to_pragma_eol (parser, pragma_tok);
if (finish_p)
return finish_omp_clauses (clauses);
{
*p = TREE_CHAIN (t);
TREE_CHAIN (t) = NULL_TREE;
- if ((flag_openmp || flag_enable_cilkplus)
+ if ((flag_openmp || flag_cilkplus)
&& is_attribute_p ("omp declare simd",
get_attribute_name (t))
&& TREE_VALUE (t))
/* If an array's index is an array notation, then its rank cannot be
greater than one. */
- if (flag_enable_cilkplus && contains_array_notation_expr (idx))
+ if (flag_cilkplus && contains_array_notation_expr (idx))
{
size_t rank = 0;
if (lhs == error_mark_node || rhs == error_mark_node)
return error_mark_node;
- if (flag_enable_cilkplus
+ if (flag_cilkplus
&& (TREE_CODE (lhs) == CILK_SPAWN_STMT
|| TREE_CODE (rhs) == CILK_SPAWN_STMT))
{
*no_warning = false;
- if (flag_enable_cilkplus && retval && TREE_CODE (retval) == CILK_SPAWN_STMT)
+ if (flag_cilkplus && retval && TREE_CODE (retval) == CILK_SPAWN_STMT)
{
error_at (EXPR_LOCATION (retval), "use of %<_Cilk_spawn%> in a return "
"statement is not allowed");
cpp_define_formatted (pfile, "__FINITE_MATH_ONLY__=%d",
flag_finite_math_only);
- if (flag_enable_cilkplus)
+ if (flag_cilkplus)
cpp_define (pfile, "__cilk=200");
}
|| (SUPPORTS_STACK_ALIGNMENT && crtl->stack_realign_needed)
/* We need a frame pointer for all Cilk Plus functions that use
Cilk keywords. */
- || (flag_enable_cilkplus && cfun->is_cilk_function)
+ || (flag_cilkplus && cfun->is_cilk_function)
|| targetm.frame_pointer_required ());
/* The chance that FRAME_POINTER_NEEDED is changed from inspecting
+2014-01-24 Balaji V. Iyer <balaji.v.iyer@intel.com>
+
+ * lto-lang.c (lto_init): Replaced flag_enable_cilkplus with
+ flag_cilkplus.
+
2014-01-09 Richard Biener <rguenther@suse.de>
* lto.c (gimple_canonical_types_compatible_p): Fix comment.
build_reference_type (va_list_type_node));
}
- if (flag_enable_cilkplus)
+ if (flag_cilkplus)
cilk_init_builtins ();
targetm.init_builtins ();
gate_expand_omp (void)
{
return ((flag_openmp != 0 || flag_openmp_simd != 0
- || flag_enable_cilkplus != 0) && !seen_error ());
+ || flag_cilkplus != 0) && !seen_error ());
}
namespace {
/* This pass always runs, to provide PROP_gimple_lomp.
But there is nothing to do unless -fopenmp is given. */
- if (flag_openmp == 0 && flag_openmp_simd == 0 && flag_enable_cilkplus == 0)
+ if (flag_openmp == 0 && flag_openmp_simd == 0 && flag_cilkplus == 0)
return 0;
all_contexts = splay_tree_new (splay_tree_compare_pointers, 0,
#endif
bool cilkplus_block = false;
- if (flag_enable_cilkplus)
+ if (flag_cilkplus)
{
if ((branch_ctx
&& gimple_code (branch_ctx) == GIMPLE_OMP_FOR
static bool
gate_diagnose_omp_blocks (void)
{
- return flag_openmp || flag_enable_cilkplus;
+ return flag_openmp || flag_cilkplus;
}
namespace {
be cloned have a distinctive artificial label in addition to "omp
declare simd". */
bool cilk_clone
- = (flag_enable_cilkplus
+ = (flag_cilkplus
&& lookup_attribute ("cilk simd function",
DECL_ATTRIBUTES (node->decl)));
/* opt_pass methods: */
bool gate () { return ((flag_openmp || flag_openmp_simd
- || flag_enable_cilkplus || (in_lto_p && !flag_wpa))
+ || flag_cilkplus || (in_lto_p && !flag_wpa))
&& (targetm.simd_clone.compute_vecsize_and_simdlen
!= NULL)); }
unsigned int execute () { return ipa_omp_simd_clone (); }
projects / thirdparty / gcc.git / commitdiff
