From 1141ed3f71c8a82067dbbbed6ec87c607bfd0be9 Mon Sep 17 00:00:00 2001 From: "Balaji V. Iyer" Date: Fri, 28 Jun 2013 20:04:36 +0000 Subject: Implemented Jason Merrill's suggestions on Array Notation C++. gcc/ChangeLog 2013-06-28 Balaji V. Iyer * builtins.def: Fixed the function type of CILKPLUS_BUILTIN. gcc/c/ChangeLog 2013-06-28 Balaji V. Iyer * c-parser.c (c_parser_array_notation): Removed rejection of array notations in an array of function pointers. gcc/c-family/ChangeLog 2013-06-28 Balaji V. Iyer * array-notation-common.c (length_mismatch_in_expr_p): Collapsed two if-statements and compared the trees directly using tree_int_cst_equal. (find_rank): Checked for array notations in function name to handle array notations in function pointers. (extract_array_notation_exprs): Likewise. (replace_array_notations): Likewise. (cilkplus_extract_an_triplets): Replaced safe_push with safe_grow_cleared. Also removed an unnecessary check to see if the node is of type ARRAY_NOTATION_REF. (fix_sec_implicit_args): Removed an unnecessary check for ADDR_EXPR. Also switched two if-statements to remove an unnecessary comparison. gcc/cp/ChangeLog 2013-06-28 Balaji V. Iyer * parser.c (cp_parser_array_notation): Removed rejection array notation of type function pointers. Added handling of array expressions when Cilk Plus is enabled. Took out type-checking. (cp_parser_postfix_open_square_expression): Moved normal array expr. parsing into cp_parser_array_notation when cilkplus is enabled. (cp_parser_compound_statement): Removed expansion of array notations. (cp_parser_ctor_initializer_opt_and_function_body): Likewise. (cp_parser_function_definition_after_declarator): Likewise. (cp_parser_selection_statement): Removed error reporting. (cp_parser_iteration_statement): Likewise. (cp_parser_direct_declarator): Removed error checking/reporting if array notations are used in the declarator. * pt.c (instantiate_decl): Likewise. (type_unification_real): Removed a check for ARRAY_NOTATION_REF. (cxx_eval_constant_expression): Removed ARRAY_NOTATION_REF case. (potential_constant_expression_1): Returned false for ARRAY_NOTATION_REF case. * cp-gimplify.c (cp_genericize): Added expansion of array notation expressions here. * cp-array-notation.c (make_triplet_val_inv): Removed loc and cry parameters. Replaced build_decls with get_temp_regvar with type as ptrdiff. (create_array_refs): Made the type-casting to ptrdiff_type. (replace_invariant_var): Added a check for void return type before creating new var. Replaced build_decl and build_min_nt_loc with get_temp_regvar. (expand_an_in_modify_expr): Ditto. Replaced body of redundant else with gcc_unreachable. Removed few unwanted checks. Made induction variable type as ptrdiff_type. Removed loc and complain arguments passed into make_triplet_val_inv. Replaced all modify expression's code from NOP EXPR to INIT EXPR. Replaced all forceful appending into stmt. list with the non-forceful one. Replaced some integer conversion and equality-checking to using tree_int_cst_equal. (expand_sec_reduce_builtin): All changes mentioned in above function expand_an_in_modify_expr. Made the new variable type of SEC_REDUCE_ANY/ALL_{NON}ZERO intrinsic functions as bool. (expand_array_notation_exprs): Removed SWITCH_EXPR case. Moved all the error reporting from parser to this function. Removed unwanted statements and checks from SWITCH_STMT, WHILE_STMT, and DO_STMT cases. (cilkplus_an_triplet_types_ok_p): Removed rejection of array notation in function pointers. (cp_expand_cond_array_notations): Added a new if statements to check if condition has a zero rank. If so, then just return. (expand_return_expr): Added a check for return expressions with a rank. Replaced get_tmp_regvar with a create_temporary_var. (build_array_notation_ref): Simplified and removed unwanted if-stmts. Moved common code outside if-statements. Moved type-checking from parser to here. * semantics.c (finish_return_stmt): Removed a check for return exprs. with a rank. * call.c (convert_like_real): Removed a check for array notation expression in a function. (build_over_call): Likewise. (magic_varargs_p): Added a check for builtin array notation function. Made this function non-static and removed its prototype. * cp-tree.h (magic_varargs_p): New prototype. * typeck.c (cp_build_function_call_vec): Removed automatic setting of nargs to the param->length when builtin reduction function is used. (convert_arguments): Replaced check for a constant_p function with margic_varargs_p function call. (cp_build_binary_op): Removed calling of the function find_correct_array_notation_type. (cp_build_addr_expr_1): Removed an unwanted if-statement. (convert_for_assignment): Removed automatic return of rhs when array notation builtin function is used. gcc/testsuite/ChangeLog 2013-06-28 Balaji V. Iyer * c-c++-common/cilk-plus/AN/decl-ptr-colon.c (main): Made this testcase c specific. * c-c++-common/cilk-plus/AN/decl-ptr-colon.c (main): Changed dg-error strings to match the fixed error messages. * c-c++-common/cilk-plus/AN/misc.c (main): Likewise. * c-c++-common/cilk-plus/AN/rank_mismatch.c (main): Added a new error message check. From-SVN: r200554 --- gcc/cp/ChangeLog | 68 ++++++ gcc/cp/call.c | 39 +-- gcc/cp/cp-array-notation.c | 582 ++++++++++++++++++++------------------------- gcc/cp/cp-gimplify.c | 6 + gcc/cp/cp-tree.h | 1 + gcc/cp/parser.c | 407 ++++++++++--------------------- gcc/cp/pt.c | 11 - gcc/cp/semantics.c | 21 +- gcc/cp/typeck.c | 32 +-- 9 files changed, 471 insertions(+), 696 deletions(-) (limited to 'gcc/cp') diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 120247d..cffed31 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,71 @@ +2013-06-28 Balaji V. Iyer + + * parser.c (cp_parser_array_notation): Removed rejection array notation + of type function pointers. Added handling of array expressions when + Cilk Plus is enabled. Took out type-checking. + (cp_parser_postfix_open_square_expression): Moved normal array expr. + parsing into cp_parser_array_notation when cilkplus is enabled. + (cp_parser_compound_statement): Removed expansion of array notations. + (cp_parser_ctor_initializer_opt_and_function_body): Likewise. + (cp_parser_function_definition_after_declarator): Likewise. + (cp_parser_selection_statement): Removed error reporting. + (cp_parser_iteration_statement): Likewise. + (cp_parser_direct_declarator): Removed error checking/reporting if + array notations are used in the declarator. + * pt.c (instantiate_decl): Likewise. + (type_unification_real): Removed a check for ARRAY_NOTATION_REF. + (cxx_eval_constant_expression): Removed ARRAY_NOTATION_REF case. + (potential_constant_expression_1): Returned false for + ARRAY_NOTATION_REF case. + * cp-gimplify.c (cp_genericize): Added expansion of array notation + expressions here. + * cp-array-notation.c (make_triplet_val_inv): Removed loc and cry + parameters. Replaced build_decls with get_temp_regvar with type as + ptrdiff. + (create_array_refs): Made the type-casting to ptrdiff_type. + (replace_invariant_var): Added a check for void return type before + creating new var. Replaced build_decl and build_min_nt_loc with + get_temp_regvar. + (expand_an_in_modify_expr): Ditto. Replaced body of redundant else + with gcc_unreachable. Removed few unwanted checks. Made induction + variable type as ptrdiff_type. Removed loc and complain arguments + passed into make_triplet_val_inv. Replaced all modify expression's + code from NOP EXPR to INIT EXPR. Replaced all forceful appending + into stmt. list with the non-forceful one. Replaced some integer + conversion and equality-checking to using tree_int_cst_equal. + (expand_sec_reduce_builtin): All changes mentioned in above function + expand_an_in_modify_expr. Made the new variable type of + SEC_REDUCE_ANY/ALL_{NON}ZERO intrinsic functions as bool. + (expand_array_notation_exprs): Removed SWITCH_EXPR case. Moved all + the error reporting from parser to this function. Removed unwanted + statements and checks from SWITCH_STMT, WHILE_STMT, and DO_STMT cases. + (cilkplus_an_triplet_types_ok_p): Removed rejection of array notation + in function pointers. + (cp_expand_cond_array_notations): Added a new if statements to check + if condition has a zero rank. If so, then just return. + (expand_return_expr): Added a check for return expressions with a rank. + Replaced get_tmp_regvar with a create_temporary_var. + (build_array_notation_ref): Simplified and removed unwanted if-stmts. + Moved common code outside if-statements. Moved type-checking from + parser to here. + * semantics.c (finish_return_stmt): Removed a check for return exprs. + with a rank. + * call.c (convert_like_real): Removed a check for array notation + expression in a function. + (build_over_call): Likewise. + (magic_varargs_p): Added a check for builtin array notation function. + Made this function non-static and removed its prototype. + * cp-tree.h (magic_varargs_p): New prototype. + * typeck.c (cp_build_function_call_vec): Removed automatic setting of + nargs to the param->length when builtin reduction function is used. + (convert_arguments): Replaced check for a constant_p function with + margic_varargs_p function call. + (cp_build_binary_op): Removed calling of the function + find_correct_array_notation_type. + (cp_build_addr_expr_1): Removed an unwanted if-statement. + (convert_for_assignment): Removed automatic return of rhs when array + notation builtin function is used. + 2013-06-28 Paolo Carlini PR c++/57682 diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 6817bfc..425ef9b 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -216,7 +216,6 @@ static void add_candidates (tree, tree, const vec *, tree, tree, bool, tree, tree, int, struct z_candidate **, tsubst_flags_t); static conversion *merge_conversion_sequences (conversion *, conversion *); -static bool magic_varargs_p (tree); static tree build_temp (tree, tree, int, diagnostic_t *, tsubst_flags_t); /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE. @@ -5857,16 +5856,9 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, else if (t->kind == ck_identity) break; } - - if (flag_enable_cilkplus - && (contains_array_notation_expr (expr) - || contains_array_notation_expr (fn))) - /* If we are using array notations, we fix them up at a later stage - and we will do these checks then. */ - ; - else if (permerror (loc, "invalid conversion from %qT to %qT", - TREE_TYPE (expr), totype) - && fn) + if (permerror (loc, "invalid conversion from %qT to %qT", + TREE_TYPE (expr), totype) + && fn) inform (DECL_SOURCE_LOCATION (fn), "initializing argument %P of %qD", argnum, fn); @@ -6515,9 +6507,12 @@ convert_for_arg_passing (tree type, tree val, tsubst_flags_t complain) which no conversions at all should be done. This is true for some builtins which don't act like normal functions. */ -static bool +bool magic_varargs_p (tree fn) { + if (flag_enable_cilkplus && is_cilkplus_reduce_builtin (fn) != BUILT_IN_NONE) + return true; + if (DECL_BUILT_IN (fn)) switch (DECL_FUNCTION_CODE (fn)) { @@ -6895,21 +6890,13 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain) " (you can disable this with -fno-deduce-init-list)"); } } + val = convert_like_with_context (conv, arg, fn, i - is_method, + conversion_warning + ? complain + : complain & (~tf_warning)); - /* If the function call is builtin array notation function then no need - to do any type conversion. */ - if (flag_enable_cilkplus - && is_cilkplus_reduce_builtin (fn) != BUILT_IN_NONE) - val = arg; - else - { - val = convert_like_with_context (conv, arg, fn, i - is_method, - conversion_warning - ? complain - : complain & (~tf_warning)); - - val = convert_for_arg_passing (type, val, complain); - } + val = convert_for_arg_passing (type, val, complain); + if (val == error_mark_node) return error_mark_node; else diff --git a/gcc/cp/cp-array-notation.c b/gcc/cp/cp-array-notation.c index 491da0f..d279ddd 100644 --- a/gcc/cp/cp-array-notation.c +++ b/gcc/cp/cp-array-notation.c @@ -59,7 +59,6 @@ #include "diagnostic.h" #include "tree-iterator.h" #include "vec.h" -#include "gimple.h" /* Creates a FOR_STMT with INIT, COND, INCR and BODY as the initializer, condition, increment expression and the loop-body, respectively. */ @@ -82,17 +81,12 @@ create_an_loop (tree init, tree cond, tree incr, tree body) a variable to make it loop invariant for array notations. */ static inline void -make_triplet_val_inv (location_t loc, tree *value, tsubst_flags_t cry) +make_triplet_val_inv (tree *value) { - tree var; if (TREE_CODE (*value) != INTEGER_CST && TREE_CODE (*value) != PARM_DECL && TREE_CODE (*value) != VAR_DECL) - { - var = build_decl (loc, VAR_DECL, NULL_TREE, integer_type_node); - finish_expr_stmt (build_x_modify_expr (loc, var, NOP_EXPR, *value, cry)); - *value = var; - } + *value = get_temp_regvar (ptrdiff_type_node, *value); } /* Returns a vector of size RANK that contains an ARRAY_REF. This vector is @@ -112,47 +106,22 @@ create_array_refs (location_t loc, vec > an_info, { tree ind_mult, ind_incr; vec *array_operand = NULL; + for (size_t ii = 0; ii < size; ii++) if (an_info[ii][0].is_vector) { tree array_opr = an_info[ii][rank - 1].value; for (int s_jj = rank -1; s_jj >= 0; s_jj--) { - tree str = NULL_TREE, v = NULL_TREE, st = NULL_TREE; - tree start = an_info[ii][s_jj].start; - tree stride = an_info[ii][s_jj].stride; - tree var = an_loop_info[s_jj].var; - - /* If stride and start are of same type and the induction var - is not, convert induction variable to stride's type. */ - if (TREE_TYPE (start) == TREE_TYPE (stride) - && TREE_TYPE (stride) != TREE_TYPE (var)) - { - st = start; - str = stride; - v = build_c_cast (loc, TREE_TYPE (str), var); - } - else if (TREE_TYPE (start) != TREE_TYPE (stride)) - { - /* If we reach here, then the stride and start are of - different types, and so it doesn't really matter what - the induction variable type is, convert everything to - integer. The reason why we pick an integer - instead of something like size_t is because the stride - and length can be + or -. */ - st = build_c_cast (loc, integer_type_node, start); - str = build_c_cast (loc, integer_type_node, stride); - v = build_c_cast (loc, integer_type_node, var); - } - else - { - st = start; - str = stride; - v = var; - } - - ind_mult = build2 (MULT_EXPR, TREE_TYPE (v), v, str); - ind_incr = build2 (PLUS_EXPR, TREE_TYPE (v), st, ind_mult); + tree start = cp_fold_convert (ptrdiff_type_node, + an_info[ii][s_jj].start); + tree stride = cp_fold_convert (ptrdiff_type_node, + an_info[ii][s_jj].stride); + tree var = cp_fold_convert (ptrdiff_type_node, + an_loop_info[s_jj].var); + + ind_mult = build2 (MULT_EXPR, TREE_TYPE (var), var, stride); + ind_incr = build2 (PLUS_EXPR, TREE_TYPE (var), start, ind_mult); /* Array [ start_index + (induction_var * stride)] */ array_opr = grok_array_decl (loc, array_opr, ind_incr, false); } @@ -192,7 +161,7 @@ replace_invariant_exprs (tree *node) { size_t ix = 0; tree node_list = NULL_TREE; - tree t = NULL_TREE, new_var = NULL_TREE, new_node; + tree t = NULL_TREE, new_var = NULL_TREE; struct inv_list data; data.list_values = NULL; @@ -204,17 +173,18 @@ replace_invariant_exprs (tree *node) { node_list = push_stmt_list (); for (ix = 0; vec_safe_iterate (data.list_values, ix, &t); ix++) - { - if (processing_template_decl || !TREE_TYPE (t)) - new_var = build_min_nt_loc (EXPR_LOCATION (t), VAR_DECL, NULL_TREE, - NULL_TREE); - else - new_var = build_decl (EXPR_LOCATION (t), VAR_DECL, NULL_TREE, - TREE_TYPE (t)); - gcc_assert (new_var != NULL_TREE && new_var != error_mark_node); - new_node = build_x_modify_expr (EXPR_LOCATION (t), new_var, NOP_EXPR, - t, tf_warning_or_error); - finish_expr_stmt (new_node); + { + /* Sometimes, when comma_expr has a function call in it, it will + typecast it to void. Find_inv_trees finds those nodes and so + if it void type, then don't bother creating a new var to hold + the return value. */ + if (VOID_TYPE_P (TREE_TYPE (t))) + { + finish_expr_stmt (t); + new_var = void_zero_node; + } + else + new_var = get_temp_regvar (TREE_TYPE (t), t); vec_safe_push (data.replacement, new_var); } cp_walk_tree (node, replace_inv_trees, (void *) &data, NULL); @@ -235,7 +205,6 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) tree new_var_type = NULL_TREE, func_parm, new_yes_expr, new_no_expr; tree array_ind_value = NULL_TREE, new_no_ind, new_yes_ind, new_no_list; tree new_yes_list, new_cond_expr, new_expr = NULL_TREE; - tree new_var_init = NULL_TREE, new_exp_init = NULL_TREE; vec *array_list = NULL, *array_operand = NULL; size_t list_size = 0, rank = 0, ii = 0; tree body, an_init, loop_with_init = alloc_stmt_list (); @@ -305,7 +274,7 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO: case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO: case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO: - new_var_type = integer_type_node; + new_var_type = boolean_type_node; break; case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND: case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND: @@ -334,24 +303,30 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) if (TREE_CODE ((*array_list)[ii]) == ARRAY_NOTATION_REF) { tree anode = (*array_list)[ii]; - make_triplet_val_inv (location, &ARRAY_NOTATION_START (anode), - tf_warning_or_error); - make_triplet_val_inv (location, &ARRAY_NOTATION_LENGTH (anode), - tf_warning_or_error); - make_triplet_val_inv (location, &ARRAY_NOTATION_STRIDE (anode), - tf_warning_or_error); + make_triplet_val_inv (&ARRAY_NOTATION_START (anode)); + make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (anode)); + make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (anode)); } cilkplus_extract_an_triplets (array_list, list_size, rank, &an_info); for (ii = 0; ii < rank; ii++) { - an_loop_info[ii].var = build_decl (location, VAR_DECL, NULL_TREE, - TREE_TYPE (an_info[0][ii].start)); - an_loop_info[ii].ind_init = build_x_modify_expr - (location, an_loop_info[ii].var, NOP_EXPR, - build_zero_cst (TREE_TYPE (an_loop_info[ii].var)), - tf_warning_or_error); + tree typ = ptrdiff_type_node; + + /* In this place, we are using get_temp_regvar instead of + create_temporary_var if an_type is SEC_REDUCE_MAX/MIN_IND because + the array_ind_value depends on this value being initalized to 0. */ + if (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND + || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND) + an_loop_info[ii].var = get_temp_regvar (typ, build_zero_cst (typ)); + else + { + an_loop_info[ii].var = create_temporary_var (typ); + add_decl_expr (an_loop_info[ii].var); + } + an_loop_info[ii].ind_init = + build_x_modify_expr (location, an_loop_info[ii].var, INIT_EXPR, + build_zero_cst (typ), tf_warning_or_error); } - array_operand = create_array_refs (location, an_info, an_loop_info, list_size, rank); replace_array_notations (&func_parm, true, array_list, array_operand); @@ -360,26 +335,9 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) TREE_TYPE (func_parm) = TREE_TYPE ((*array_list)[0]); create_cmp_incr (location, &an_loop_info, rank, an_info, tf_warning_or_error); - if (an_type != BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING) - { - if (processing_template_decl) - *new_var = build_decl (location, VAR_DECL, NULL_TREE, new_var_type); - else - *new_var = create_tmp_var (new_var_type, NULL); - } - else - /* We do not require a new variable for mutating. The "identity value" - itself is the variable. */ - *new_var = NULL_TREE; - if (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND - || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND) - { - array_ind_value = create_tmp_var (TREE_TYPE (func_parm), NULL); - gcc_assert (array_ind_value && (array_ind_value != error_mark_node)); - DECL_INITIAL (array_ind_value) = NULL_TREE; - pushdecl (array_ind_value); - } + || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND) + array_ind_value = get_temp_regvar (TREE_TYPE (func_parm), func_parm); array_op0 = (*array_operand)[0]; switch (an_type) @@ -394,35 +352,36 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) break; case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO: case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO: - code = (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO) ? EQ_EXPR - : NE_EXPR; + code = ((an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO) ? EQ_EXPR + : NE_EXPR); init = build_zero_cst (new_var_type); cond_init = build_one_cst (new_var_type); comp_node = build_zero_cst (TREE_TYPE (func_parm)); break; case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO: case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO: - code = (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO) ? NE_EXPR - : EQ_EXPR; + code = ((an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO) ? NE_EXPR + : EQ_EXPR); init = build_one_cst (new_var_type); cond_init = build_zero_cst (new_var_type); comp_node = build_zero_cst (TREE_TYPE (func_parm)); break; case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX: code = MAX_EXPR; - init = TYPE_MIN_VALUE (new_var_type) ? TYPE_MIN_VALUE (new_var_type) - : func_parm; + init = (TYPE_MIN_VALUE (new_var_type) ? TYPE_MIN_VALUE (new_var_type) + : func_parm); break; case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN: code = MIN_EXPR; - init = TYPE_MAX_VALUE (new_var_type) ? TYPE_MAX_VALUE (new_var_type) - : func_parm; + init = (TYPE_MAX_VALUE (new_var_type) ? TYPE_MAX_VALUE (new_var_type) + : func_parm); break; case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND: case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND: - code = an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND ? LE_EXPR - : GE_EXPR; + code = (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND ? LE_EXPR + : GE_EXPR); init = an_loop_info[0].var; + break; case BUILT_IN_CILKPLUS_SEC_REDUCE: init = identity_value; break; @@ -433,9 +392,11 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) gcc_unreachable (); } - if (init) - new_var_init = build_x_modify_expr (location, *new_var, NOP_EXPR, init, - tf_warning_or_error); + if (an_type != BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING) + *new_var = get_temp_regvar (new_var_type, init); + else + *new_var = NULL_TREE; + switch (an_type) { case BUILT_IN_CILKPLUS_SEC_REDUCE_ADD: @@ -470,8 +431,6 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) break; case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND: case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND: - new_exp_init = build_x_modify_expr (location, array_ind_value, NOP_EXPR, - func_parm, tf_warning_or_error); new_yes_expr = build_x_modify_expr (location, array_ind_value, NOP_EXPR, func_parm, tf_warning_or_error); new_no_expr = build_x_modify_expr (location, array_ind_value, NOP_EXPR, @@ -521,21 +480,8 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) default: gcc_unreachable (); } - - /* The reason we are putting initial variable twice is because the - new exp init below depends on this value being initialized. */ - for (ii = 0; ii < rank; ii++) - finish_expr_stmt (an_loop_info[ii].ind_init); - - if (an_type != BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING) - finish_expr_stmt (new_var_init); - - if (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND - || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND) - finish_expr_stmt (new_exp_init); - an_init = pop_stmt_list (an_init); - append_to_statement_list_force (an_init, &loop_with_init); + append_to_statement_list (an_init, &loop_with_init); body = new_expr; for (ii = 0; ii < rank; ii++) @@ -545,7 +491,7 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var) an_loop_info[ii].incr, body); body = pop_stmt_list (new_loop); } - append_to_statement_list_force (body, &loop_with_init); + append_to_statement_list (body, &loop_with_init); an_info.release (); an_loop_info.release (); @@ -634,10 +580,7 @@ expand_an_in_modify_expr (location_t location, tree lhs, return an_init; } else - { - pop_stmt_list (an_init); - return NULL_TREE; - } + gcc_unreachable (); } /* If for some reason location is not set, then find if LHS or RHS has @@ -659,8 +602,6 @@ expand_an_in_modify_expr (location_t location, tree lhs, if (lhs_rank == 0 && rhs_rank != 0) { - if (location == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (rhs)) - location = EXPR_LOCATION (rhs); error_at (location, "%qD cannot be scalar when %qD is not", lhs, rhs); return error_mark_node; } @@ -675,17 +616,17 @@ expand_an_in_modify_expr (location_t location, tree lhs, for (ii = 0; ii < lhs_list_size; ii++) { tree anode = (*lhs_list)[ii]; - make_triplet_val_inv (location, &ARRAY_NOTATION_START (anode), complain); - make_triplet_val_inv (location, &ARRAY_NOTATION_LENGTH (anode), complain); - make_triplet_val_inv (location, &ARRAY_NOTATION_STRIDE (anode), complain); + make_triplet_val_inv (&ARRAY_NOTATION_START (anode)); + make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (anode)); + make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (anode)); } for (ii = 0; ii < rhs_list_size; ii++) if ((*rhs_list)[ii] && TREE_CODE ((*rhs_list)[ii]) == ARRAY_NOTATION_REF) { tree aa = (*rhs_list)[ii]; - make_triplet_val_inv (location, &ARRAY_NOTATION_START (aa), complain); - make_triplet_val_inv (location, &ARRAY_NOTATION_LENGTH (aa), complain); - make_triplet_val_inv (location, &ARRAY_NOTATION_STRIDE (aa), complain); + make_triplet_val_inv (&ARRAY_NOTATION_START (aa)); + make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (aa)); + make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (aa)); } lhs_an_loop_info.safe_grow_cleared (lhs_rank); @@ -705,31 +646,29 @@ expand_an_in_modify_expr (location_t location, tree lhs, pop_stmt_list (an_init); return error_mark_node; } - tree rhs_len = (rhs_list_size > 0 && rhs_rank > 0) ? - rhs_an_info[0][0].length : NULL_TREE; - tree lhs_len = (lhs_list_size > 0 && lhs_rank > 0) ? - lhs_an_info[0][0].length : NULL_TREE; + tree rhs_len = ((rhs_list_size > 0 && rhs_rank > 0) ? + rhs_an_info[0][0].length : NULL_TREE); + tree lhs_len = ((lhs_list_size > 0 && lhs_rank > 0) ? + lhs_an_info[0][0].length : NULL_TREE); if (lhs_list_size > 0 && rhs_list_size > 0 && lhs_rank > 0 && rhs_rank > 0 && TREE_CODE (lhs_len) == INTEGER_CST && rhs_len - && TREE_CODE (rhs_len) == INTEGER_CST) - { - HOST_WIDE_INT l_length = int_cst_value (lhs_len); - HOST_WIDE_INT r_length = int_cst_value (rhs_len); - if (absu_hwi (l_length) != absu_hwi (r_length)) - { - error_at (location, "length mismatch between LHS and RHS"); - pop_stmt_list (an_init); - return error_mark_node; - } + && TREE_CODE (rhs_len) == INTEGER_CST + && !tree_int_cst_equal (rhs_len, lhs_len)) + { + error_at (location, "length mismatch between LHS and RHS"); + pop_stmt_list (an_init); + return error_mark_node; } - for (ii = 0; ii < lhs_rank; ii++) - if (lhs_an_info[0][ii].start && TREE_TYPE (lhs_an_info[0][ii].start)) - lhs_an_loop_info[ii].var = - build_decl (location, VAR_DECL, NULL_TREE, - TREE_TYPE (lhs_an_info[0][ii].start)); - else - lhs_an_loop_info[ii].var = build_decl (location, VAR_DECL, NULL_TREE, - integer_type_node); + for (ii = 0; ii < lhs_rank; ii++) + { + tree typ = ptrdiff_type_node; + lhs_an_loop_info[ii].var = create_temporary_var (typ); + add_decl_expr (lhs_an_loop_info[ii].var); + lhs_an_loop_info[ii].ind_init = build_x_modify_expr + (location, lhs_an_loop_info[ii].var, INIT_EXPR, build_zero_cst (typ), + complain); + } + if (rhs_list_size > 0) { rhs_array_operand = fix_sec_implicit_args (location, rhs_list, @@ -743,24 +682,15 @@ expand_an_in_modify_expr (location_t location, tree lhs, rhs_list = NULL; extract_array_notation_exprs (rhs, true, &rhs_list); rhs_list_size = vec_safe_length (rhs_list); - - for (ii = 0; ii < lhs_rank; ii++) - if (lhs_an_info[0][ii].is_vector) - { - lhs_an_loop_info[ii].ind_init = build_x_modify_expr - (location, lhs_an_loop_info[ii].var, NOP_EXPR, - build_zero_cst (TREE_TYPE (lhs_an_loop_info[ii].var)), complain); - } + for (ii = 0; ii < rhs_rank; ii++) { - /* When we have a polynomial, we assume that the indices are of type - integer. */ - rhs_an_loop_info[ii].var = - build_decl (location, VAR_DECL, NULL_TREE, - TREE_TYPE (rhs_an_info[0][ii].start)); + tree typ = ptrdiff_type_node; + rhs_an_loop_info[ii].var = create_temporary_var (typ); + add_decl_expr (rhs_an_loop_info[ii].var); rhs_an_loop_info[ii].ind_init = build_x_modify_expr - (location, rhs_an_loop_info[ii].var, NOP_EXPR, - build_zero_cst (TREE_TYPE (rhs_an_loop_info[ii].var)), complain); + (location, rhs_an_loop_info[ii].var, INIT_EXPR, build_zero_cst (typ), + complain); } if (lhs_rank) @@ -809,12 +739,12 @@ expand_an_in_modify_expr (location_t location, tree lhs, else if (ii < lhs_rank && ii >= rhs_rank) cond_expr[ii] = lhs_an_loop_info[ii].cmp; else - /* No need to compare ii < rhs_rank && ii >= lhs_rank because valid Array - notation expression cannot RHS's rank cannot be greater than LHS. */ + /* No need to compare ii < rhs_rank && ii >= lhs_rank because in a valid + Array notation expression, rank of RHS cannot be greater than LHS. */ gcc_unreachable (); an_init = pop_stmt_list (an_init); - append_to_statement_list_force (an_init, &loop_with_init); + append_to_statement_list (an_init, &loop_with_init); body = array_expr; for (ii = 0; ii < MAX (lhs_rank, rhs_rank); ii++) { @@ -824,17 +754,13 @@ expand_an_in_modify_expr (location_t location, tree lhs, if (lhs_rank) { - append_to_statement_list_force (lhs_an_loop_info[ii].ind_init, - &init_list); - append_to_statement_list_force (lhs_an_loop_info[ii].incr, - &incr_list); + append_to_statement_list (lhs_an_loop_info[ii].ind_init, &init_list); + append_to_statement_list (lhs_an_loop_info[ii].incr, &incr_list); } if (rhs_rank) { - append_to_statement_list_force (rhs_an_loop_info[ii].ind_init, - &init_list); - append_to_statement_list_force (rhs_an_loop_info[ii].incr, - &incr_list); + append_to_statement_list (rhs_an_loop_info[ii].ind_init, &init_list); + append_to_statement_list (rhs_an_loop_info[ii].incr, &incr_list); } create_an_loop (init_list, cond_expr[ii], incr_list, body); body = pop_stmt_list (new_loop); @@ -867,7 +793,6 @@ cp_expand_cond_array_notations (tree orig_stmt) tree an_init, body, stmt = NULL_TREE; tree builtin_loop, new_var = NULL_TREE; tree loop_with_init = alloc_stmt_list (); - tsubst_flags_t complain = tf_warning_or_error; location_t location = UNKNOWN_LOCATION; vec > an_info = vNULL; vec an_loop_info = vNULL; @@ -884,13 +809,17 @@ cp_expand_cond_array_notations (tree orig_stmt) || find_rank (EXPR_LOCATION (no_expr), no_expr, no_expr, true, &no_rank)) return error_mark_node; - if (cond_rank != 0 && cond_rank != yes_rank && yes_rank != 0) + /* If the condition has a zero rank, then handle array notations in body + seperately. */ + if (cond_rank == 0) + return orig_stmt; + if (cond_rank != yes_rank && yes_rank != 0) { error_at (EXPR_LOCATION (yes_expr), "rank mismatch with controlling" " expression of parent if-statement"); return error_mark_node; } - else if (cond_rank != 0 && cond_rank != no_rank && no_rank != 0) + else if (cond_rank != no_rank && no_rank != 0) { error_at (EXPR_LOCATION (no_expr), "rank mismatch with controlling " "expression of parent if-statement"); @@ -911,13 +840,17 @@ cp_expand_cond_array_notations (tree orig_stmt) && !find_rank (EXPR_LOCATION (no_expr), no_expr, no_expr, true, &no_rank))) return error_mark_node; - if (cond_rank != 0 && cond_rank != yes_rank && yes_rank != 0) + + /* Same reasoning as for COND_EXPR. */ + if (cond_rank == 0) + return orig_stmt; + else if (cond_rank != yes_rank && yes_rank != 0) { error_at (EXPR_LOCATION (yes_expr), "rank mismatch with controlling" " expression of parent if-statement"); return error_mark_node; } - else if (cond_rank != 0 && cond_rank != no_rank && no_rank != 0) + else if (cond_rank != no_rank && no_rank != 0) { error_at (EXPR_LOCATION (no_expr), "rank mismatch with controlling " "expression of parent if-statement"); @@ -949,11 +882,11 @@ cp_expand_cond_array_notations (tree orig_stmt) vec_safe_push (new_var_list, new_var); replace_array_notations (&orig_stmt, false, sub_list, new_var_list); - append_to_statement_list_force (builtin_loop, &stmt); + append_to_statement_list (builtin_loop, &stmt); } } } - append_to_statement_list_force (orig_stmt, &stmt); + append_to_statement_list (orig_stmt, &stmt); rank = 0; array_list = NULL; if (!find_rank (EXPR_LOCATION (stmt), stmt, stmt, true, &rank)) @@ -977,37 +910,28 @@ cp_expand_cond_array_notations (tree orig_stmt) for (ii = 0; ii < list_size; ii++) { tree anode = (*array_list)[ii]; - make_triplet_val_inv (location, &ARRAY_NOTATION_START (anode), complain); - make_triplet_val_inv (location, &ARRAY_NOTATION_LENGTH (anode), complain); - make_triplet_val_inv (location, &ARRAY_NOTATION_STRIDE (anode), complain); + make_triplet_val_inv (&ARRAY_NOTATION_START (anode)); + make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (anode)); + make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (anode)); } cilkplus_extract_an_triplets (array_list, list_size, rank, &an_info); - for (ii = 0; ii < rank; ii++) - if (TREE_TYPE (an_info[0][ii].start) - && TREE_CODE (TREE_TYPE (an_info[0][ii].start)) != TEMPLATE_TYPE_PARM) - { - an_loop_info[ii].var = build_decl (location, VAR_DECL, NULL_TREE, - TREE_TYPE (an_info[0][ii].start)); - an_loop_info[ii].ind_init = build_x_modify_expr - (location, an_loop_info[ii].var, NOP_EXPR, - build_zero_cst (TREE_TYPE (an_loop_info[ii].var)), - tf_warning_or_error); - } - else - { - an_loop_info[ii].var = build_min_nt_loc (location, VAR_DECL, - NULL_TREE, NULL_TREE); - an_loop_info[ii].ind_init = - build_x_modify_expr (location, an_loop_info[ii].var, NOP_EXPR, - integer_zero_node, tf_warning_or_error); - } + + for (ii = 0; ii < rank; ii++) + { + tree typ = ptrdiff_type_node; + an_loop_info[ii].var = create_temporary_var (typ); + add_decl_expr (an_loop_info[ii].var); + an_loop_info[ii].ind_init = + build_x_modify_expr (location, an_loop_info[ii].var, INIT_EXPR, + build_zero_cst (typ), tf_warning_or_error); + } array_operand = create_array_refs (location, an_info, an_loop_info, list_size, rank); replace_array_notations (&stmt, true, array_list, array_operand); create_cmp_incr (location, &an_loop_info, rank, an_info, tf_warning_or_error); an_init = pop_stmt_list (an_init); - append_to_statement_list_force (an_init, &loop_with_init); + append_to_statement_list (an_init, &loop_with_init); body = stmt; for (ii = 0; ii < rank; ii++) @@ -1017,7 +941,7 @@ cp_expand_cond_array_notations (tree orig_stmt) an_loop_info[ii].incr, body); body = pop_stmt_list (new_loop); } - append_to_statement_list_force (body, &loop_with_init); + append_to_statement_list (body, &loop_with_init); an_info.release (); an_loop_info.release (); @@ -1062,14 +986,14 @@ expand_unary_array_notation_exprs (tree orig_stmt) { vec *sub_list = NULL, *new_var_list = NULL; stmt = alloc_stmt_list (); - append_to_statement_list_force (builtin_loop, &stmt); + append_to_statement_list (builtin_loop, &stmt); vec_safe_push (sub_list, list_node); vec_safe_push (new_var_list, new_var); replace_array_notations (&orig_stmt, false, sub_list, new_var_list); } } if (stmt != NULL_TREE) - append_to_statement_list_force (finish_expr_stmt (orig_stmt), &stmt); + append_to_statement_list (finish_expr_stmt (orig_stmt), &stmt); else stmt = orig_stmt; rank = 0; @@ -1089,22 +1013,19 @@ expand_unary_array_notation_exprs (tree orig_stmt) for (ii = 0; ii < list_size; ii++) { tree array_node = (*array_list)[ii]; - make_triplet_val_inv (location, &ARRAY_NOTATION_START (array_node), - tf_warning_or_error); - make_triplet_val_inv (location, &ARRAY_NOTATION_LENGTH (array_node), - tf_warning_or_error); - make_triplet_val_inv (location, &ARRAY_NOTATION_STRIDE (array_node), - tf_warning_or_error); + make_triplet_val_inv (&ARRAY_NOTATION_START (array_node)); + make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (array_node)); + make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (array_node)); } cilkplus_extract_an_triplets (array_list, list_size, rank, &an_info); for (ii = 0; ii < rank; ii++) { - an_loop_info[ii].var = build_decl (location, VAR_DECL, NULL_TREE, - TREE_TYPE (an_info[0][ii].start)); + tree typ = ptrdiff_type_node; + an_loop_info[ii].var = create_temporary_var (typ); + add_decl_expr (an_loop_info[ii].var); an_loop_info[ii].ind_init = build_x_modify_expr - (location, an_loop_info[ii].var, NOP_EXPR, - build_zero_cst (TREE_TYPE (an_loop_info[ii].var)), + (location, an_loop_info[ii].var, INIT_EXPR, build_zero_cst (typ), tf_warning_or_error); } array_operand = create_array_refs (location, an_info, an_loop_info, @@ -1113,7 +1034,7 @@ expand_unary_array_notation_exprs (tree orig_stmt) create_cmp_incr (location, &an_loop_info, rank, an_info, tf_warning_or_error); an_init = pop_stmt_list (an_init); - append_to_statement_list_force (an_init, &loop_with_init); + append_to_statement_list (an_init, &loop_with_init); body = stmt; for (ii = 0; ii < rank; ii++) @@ -1123,7 +1044,7 @@ expand_unary_array_notation_exprs (tree orig_stmt) an_loop_info[ii].incr, body); body = pop_stmt_list (new_loop); } - append_to_statement_list_force (body, &loop_with_init); + append_to_statement_list (body, &loop_with_init); an_info.release (); an_loop_info.release (); @@ -1139,21 +1060,35 @@ static tree expand_return_expr (tree expr) { tree new_mod_list, new_var, new_mod, retval_expr; - + size_t rank = 0; + location_t loc = EXPR_LOCATION (expr); if (TREE_CODE (expr) != RETURN_EXPR) return expr; + + if (!find_rank (loc, expr, expr, false, &rank)) + return error_mark_node; - location_t loc = EXPR_LOCATION (expr); - new_mod_list = alloc_stmt_list (); + /* If the return expression contains array notations, then flag it as + error. */ + if (rank >= 1) + { + error_at (loc, "array notation expression cannot be used as a return " + "value"); + return error_mark_node; + } + + new_mod_list = push_stmt_list (); retval_expr = TREE_OPERAND (expr, 0); - new_var = build_decl (loc, VAR_DECL, NULL_TREE, TREE_TYPE (retval_expr)); + new_var = create_temporary_var (TREE_TYPE (retval_expr)); + add_decl_expr (new_var); new_mod = expand_an_in_modify_expr (loc, new_var, NOP_EXPR, - TREE_OPERAND (retval_expr, 1), - tf_warning_or_error); + TREE_OPERAND (retval_expr, 1), + tf_warning_or_error); TREE_OPERAND (retval_expr, 1) = new_var; TREE_OPERAND (expr, 0) = retval_expr; - append_to_statement_list_force (new_mod, &new_mod_list); - append_to_statement_list_force (expr, &new_mod_list); + add_stmt (new_mod); + add_stmt (expr); + new_mod_list = pop_stmt_list (new_mod_list); return new_mod_list; } @@ -1290,19 +1225,21 @@ expand_array_notation_exprs (tree t) else t = expand_array_notation_exprs (t); return t; - - case SWITCH_EXPR: - t = cp_expand_cond_array_notations (t); - if (TREE_CODE (t) == SWITCH_EXPR) - SWITCH_BODY (t) = expand_array_notation_exprs (SWITCH_BODY (t)); - else - t = expand_array_notation_exprs (t); - return t; - case FOR_STMT: + case FOR_STMT: + if (contains_array_notation_expr (FOR_COND (t))) + { + error_at (EXPR_LOCATION (FOR_COND (t)), + "array notation cannot be used in a condition for " + "a for-loop"); + return error_mark_node; + } /* FIXME: Add a check for CILK_FOR_STMT here when we add Cilk tasking keywords. */ if (TREE_CODE (t) == FOR_STMT) - FOR_BODY (t) = expand_array_notation_exprs (FOR_BODY (t)); + { + FOR_BODY (t) = expand_array_notation_exprs (FOR_BODY (t)); + FOR_EXPR (t) = expand_array_notation_exprs (FOR_EXPR (t)); + } else t = expand_array_notation_exprs (t); return t; @@ -1322,44 +1259,39 @@ expand_array_notation_exprs (tree t) t = expand_array_notation_exprs (t); return t; case SWITCH_STMT: - t = cp_expand_cond_array_notations (t); - /* If the above function added some extra instructions above the original - switch statement, then we can't assume it is still SWITCH_STMT so we - have to check again. */ - if (TREE_CODE (t) == SWITCH_STMT) + if (contains_array_notation_expr (SWITCH_STMT_COND (t))) { - if (SWITCH_STMT_BODY (t)) - SWITCH_STMT_BODY (t) = - expand_array_notation_exprs (SWITCH_STMT_BODY (t)); + error_at (EXPR_LOCATION (SWITCH_STMT_COND (t)), + "array notation cannot be used as a condition for " + "switch statement"); + return error_mark_node; } - else - t = expand_array_notation_exprs (t); + if (SWITCH_STMT_BODY (t)) + SWITCH_STMT_BODY (t) = + expand_array_notation_exprs (SWITCH_STMT_BODY (t)); return t; case WHILE_STMT: - t = cp_expand_cond_array_notations (t); - /* If the above function added some extra instructions above the original - while statement, then we can't assume it is still WHILE_STMTso we - have to check again. */ - if (TREE_CODE (t) == WHILE_STMT) + if (contains_array_notation_expr (WHILE_COND (t))) { - if (WHILE_BODY (t)) - WHILE_BODY (t) = expand_array_notation_exprs (WHILE_BODY (t)); + if (EXPR_LOCATION (WHILE_COND (t)) != UNKNOWN_LOCATION) + loc = EXPR_LOCATION (WHILE_COND (t)); + error_at (loc, "array notation cannot be used as a condition for " + "while statement"); + return error_mark_node; } - else - t = expand_array_notation_exprs (t); + if (WHILE_BODY (t)) + WHILE_BODY (t) = expand_array_notation_exprs (WHILE_BODY (t)); return t; case DO_STMT: - t = cp_expand_cond_array_notations (t); - /* If the above function added some extra instructions above the original - do-while statement, then we can't assume it is still DO_STMT so we - have to check again. */ - if (TREE_CODE (t) == DO_STMT) - { - if (DO_BODY (t)) - DO_BODY (t) = expand_array_notation_exprs (DO_BODY (t)); + if (contains_array_notation_expr (DO_COND (t))) + { + error_at (EXPR_LOCATION (DO_COND (t)), + "array notation cannot be used as a condition for a " + "do-while statement"); + return error_mark_node; } - else - t = expand_array_notation_exprs (t); + if (DO_BODY (t)) + DO_BODY (t) = expand_array_notation_exprs (DO_BODY (t)); return t; default: if (is_expr) @@ -1380,59 +1312,66 @@ expand_array_notation_exprs (tree t) return t; } -/* Given the base of an array (ARRAY), the START_INDEX, the number of elements - to be accessed (LENGTH) and the STRIDE, construct an ARRAY_NOTATION_REF tree - of type TYPE and return it. Restrictions on START_INDEX, LENGTH and STRIDE - are the same as that of index field passed into ARRAY_REF. The only - additional restriction is that, unlike index in ARRAY_REF, stride, length - and start_index cannot contain array notations. */ +/* Given the base of an array (ARRAY), the START (start_index), the number of + elements to be accessed (LENGTH) and the STRIDE, construct an + ARRAY_NOTATION_REF tree of type TYPE and return it. Restrictions on START, + LENGTH and STRIDE are the same as that of index field passed into ARRAY_REF. + The only additional restriction is that, unlike index in ARRAY_REF, stride, + length and start_index cannot contain array notations. */ tree -build_array_notation_ref (location_t loc, tree array, tree start_index, - tree length, tree stride, tree type) +build_array_notation_ref (location_t loc, tree array, tree start, tree length, + tree stride, tree type) { tree array_ntn_expr = NULL_TREE; - - /* When dealing with templates, do the type checking at a later time. */ - if (processing_template_decl || !type) + + /* If we enter the then-case of the if-statement below, we have hit a case + like this: ARRAY [:]. */ + if (!start && !length) { - if (!type && TREE_TYPE (array)) - type = TREE_TYPE (array); - array_ntn_expr = build_min_nt_loc (loc, ARRAY_NOTATION_REF, array, - start_index, length, stride, type, - NULL_TREE); - TREE_TYPE (array_ntn_expr) = type; + if (TREE_CODE (type) != ARRAY_TYPE) + { + error_at (loc, "start-index and length fields necessary for " + "using array notation in pointers or records"); + return error_mark_node; + } + tree domain = TYPE_DOMAIN (type); + if (!domain) + { + error_at (loc, "start-index and length fields necessary for " + "using array notation with array of unknown bound"); + return error_mark_node; + } + start = cp_fold_convert (ptrdiff_type_node, TYPE_MINVAL (domain)); + length = size_binop (PLUS_EXPR, TYPE_MAXVAL (domain), size_one_node); + length = cp_fold_convert (ptrdiff_type_node, length); } - if (!stride) - { - if (TREE_CONSTANT (start_index) && TREE_CONSTANT (length) - && TREE_CODE (start_index) != VAR_DECL - && TREE_CODE (length) != VAR_DECL - && tree_int_cst_lt (length, start_index)) - stride = build_int_cst (TREE_TYPE (start_index), -1); - else - stride = build_int_cst (TREE_TYPE (start_index), 1); + + if (!stride) + stride = build_one_cst (ptrdiff_type_node); + + /* When dealing with templates, triplet type-checking will be done in pt.c + after type substitution. */ + if (processing_template_decl + && (type_dependent_expression_p (array) + || type_dependent_expression_p (length) + || type_dependent_expression_p (start) + || type_dependent_expression_p (stride))) + array_ntn_expr = build_min_nt_loc (loc, ARRAY_NOTATION_REF, array, start, + length, stride, NULL_TREE); + else + { + if (!cilkplus_an_triplet_types_ok_p (loc, start, length, stride, type)) + return error_mark_node; + array_ntn_expr = build4 (ARRAY_NOTATION_REF, NULL_TREE, array, start, + length, stride); } + if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == POINTER_TYPE) + TREE_TYPE (array_ntn_expr) = TREE_TYPE (type); + else + gcc_unreachable (); - if (!cilkplus_an_triplet_types_ok_p (loc, start_index, length, stride, type)) - return error_mark_node; - - if (!processing_template_decl) - { - array_ntn_expr = build4 (ARRAY_NOTATION_REF, NULL_TREE, NULL_TREE, - NULL_TREE, NULL_TREE, NULL_TREE); - ARRAY_NOTATION_ARRAY (array_ntn_expr) = array; - ARRAY_NOTATION_START (array_ntn_expr) = start_index; - ARRAY_NOTATION_LENGTH (array_ntn_expr) = length; - ARRAY_NOTATION_STRIDE (array_ntn_expr) = stride; - if (type && (TREE_CODE (type) == ARRAY_TYPE - || TREE_CODE (type) == POINTER_TYPE)) - TREE_TYPE (array_ntn_expr) = TREE_TYPE (type); - else - TREE_TYPE (array_ntn_expr) = type; - } SET_EXPR_LOCATION (array_ntn_expr, loc); - return array_ntn_expr; } @@ -1462,20 +1401,9 @@ cilkplus_an_triplet_types_ok_p (location_t loc, tree start_index, tree length, } if (!TREE_CODE (type) == FUNCTION_TYPE) { - error_at (loc, "array notations cannot be used with function type"); + error_at (loc, "array notation cannot be used with function type"); return false; } - while (type && (TREE_CODE (type) == POINTER_TYPE - || TREE_CODE (type) == ARRAY_TYPE)) - { - type = TREE_TYPE (type); - if (type && TREE_CODE (type) == FUNCTION_TYPE) - { - error_at (loc, "array notations cannot be used with function pointer" - " arrays"); - return false; - } - } if (!find_rank (loc, start_index, start_index, false, &start_rank) || !find_rank (loc, length, length, false, &length_rank) || !find_rank (loc, stride, stride, false, &stride_rank)) diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c index 38ef878..590d857 100644 --- a/gcc/cp/cp-gimplify.c +++ b/gcc/cp/cp-gimplify.c @@ -1207,6 +1207,12 @@ cp_genericize (tree fndecl) if (DECL_CLONED_FUNCTION_P (fndecl)) return; + /* Expand all the array notations here. */ + if (flag_enable_cilkplus + && contains_array_notation_expr (DECL_SAVED_TREE (fndecl))) + DECL_SAVED_TREE (fndecl) = + expand_array_notation_exprs (DECL_SAVED_TREE (fndecl)); + /* We do want to see every occurrence of the parms, so we can't just use walk_tree's hash functionality. */ cp_genericize_tree (&DECL_SAVED_TREE (fndecl)); diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 4b2cd51..d3dd494 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -4974,6 +4974,7 @@ extern bool pragma_java_exceptions; /* in call.c */ extern bool check_dtor_name (tree, tree); +bool magic_varargs_p (tree); extern tree build_conditional_expr (location_t, tree, tree, tree, tsubst_flags_t); diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index c6ecf69..281e163 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -6062,41 +6062,31 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, return error_mark_node; } -/* This function parses Cilk Plus array notations. The starting index is - passed in INIT_INDEX and the array name is passed in ARRAY_VALUE. If the - INIT_INDEX is NULL, then we have special case were the entire array is - accessed (e.g. A[:]). The return value of this function is a tree node - called VALUE_TREE of type ARRAY_NOTATION_REF. If some error occurred it - returns error_mark_node. */ +/* This function parses Cilk Plus array notations. If a normal array expr. is + parsed then the array index is passed back to the caller through *INIT_INDEX + and the function returns a NULL_TREE. If array notation expr. is parsed, + then *INIT_INDEX is ignored by the caller and the function returns + a tree of type ARRAY_NOTATION_REF. If some error occurred it returns + error_mark_node. */ static tree -cp_parser_array_notation (location_t loc, cp_parser *parser, tree init_index, +cp_parser_array_notation (location_t loc, cp_parser *parser, tree *init_index, tree array_value) { cp_token *token = NULL; - tree start_index = NULL_TREE, length_index = NULL_TREE, stride = NULL_TREE; - tree value_tree, type, array_type, array_type_domain; - double_int x; - bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p; - + tree length_index, stride = NULL_TREE, value_tree, array_type; if (!array_value || array_value == error_mark_node) { cp_parser_skip_to_end_of_statement (parser); return error_mark_node; } + + array_type = TREE_TYPE (array_value); - if (processing_template_decl) - { - array_type = TREE_TYPE (array_value); - type = TREE_TYPE (array_type); - } - else - { - array_type = TREE_TYPE (array_value); - gcc_assert (array_type); - type = array_type; - } + bool saved_colon_corrects = parser->colon_corrects_to_scope_p; + parser->colon_corrects_to_scope_p = false; token = cp_lexer_peek_token (parser->lexer); + if (!token) { cp_parser_error (parser, "expected %<:%> or numeral"); @@ -6104,125 +6094,57 @@ cp_parser_array_notation (location_t loc, cp_parser *parser, tree init_index, } else if (token->type == CPP_COLON) { - if (!init_index) + /* Consume the ':'. */ + cp_lexer_consume_token (parser->lexer); + + /* If we are here, then we have a case like this A[:]. */ + if (cp_lexer_peek_token (parser->lexer)->type != CPP_CLOSE_SQUARE) { - /* If we are here, then we have a case like this A[:]. */ - cp_lexer_consume_token (parser->lexer); - - if (cp_lexer_peek_token (parser->lexer)->type != CPP_CLOSE_SQUARE) - { - cp_parser_error (parser, "expected %<]%>"); - cp_parser_skip_to_end_of_statement (parser); - return error_mark_node; - } - if (TREE_CODE (array_type) == RECORD_TYPE - || TREE_CODE (array_type) == POINTER_TYPE) - { - error_at (loc, "start-index and length fields necessary for " - "using array notations in pointers or records"); - cp_parser_skip_to_end_of_statement (parser); - return error_mark_node; - } - if (TREE_CODE (array_type) == ARRAY_TYPE) - { - tree subtype = TREE_TYPE (array_type); - while (subtype && TREE_CODE (subtype) == POINTER_TYPE) - { - /* This could be a function ptr. If so, then emit error. */ - subtype = TREE_TYPE (subtype); - if (subtype && TREE_CODE (subtype) == FUNCTION_TYPE) - { - error_at (loc, "array notations cannot be used with" - " function pointer arrays"); - cp_parser_skip_to_end_of_statement (parser); - return error_mark_node; - } - } - } - array_type_domain = TYPE_DOMAIN (array_type); - if (!array_type_domain) - { - error_at (loc, "start-index and length fields necessary for " - "using array notations in dimensionless arrays"); - cp_parser_skip_to_end_of_statement (parser); - return error_mark_node; - } - start_index = TYPE_MINVAL (array_type_domain); - start_index = fold_build1 (CONVERT_EXPR, ptrdiff_type_node, - start_index); - x = TREE_INT_CST (TYPE_MAXVAL (array_type_domain)); - x.low++; - length_index = double_int_to_tree (integer_type_node, x); - length_index = fold_build1 (CONVERT_EXPR, ptrdiff_type_node, - length_index); - stride = build_int_cst (integer_type_node, 1); - stride = fold_build1 (CONVERT_EXPR, ptrdiff_type_node, stride); - } - else if (init_index != error_mark_node) - { - /* If we hare here, then there are 2 possibilities: - 1. Array [ EXPR : EXPR ] - 2. Array [ EXPR : EXPR : EXPR ] - */ - start_index = init_index; - cp_lexer_consume_token (parser->lexer); + cp_parser_error (parser, "expected %<]%>"); + cp_parser_skip_to_end_of_statement (parser); + return error_mark_node; + } + *init_index = NULL_TREE; + stride = NULL_TREE; + length_index = NULL_TREE; + } + else + { + /* If we are here, then there are three valid possibilities: + 1. ARRAY [ EXP ] + 2. ARRAY [ EXP : EXP ] + 3. ARRAY [ EXP : EXP : EXP ] */ - saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p; - /* The ':' is used in array notation. Thus compiler cannot do scope - correction automatically. */ - parser->colon_corrects_to_scope_p = false; - length_index = cp_parser_expression (parser, false, NULL); - parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p; - if (!length_index || length_index == error_mark_node) - cp_parser_skip_to_end_of_statement (parser); - - if (cp_lexer_peek_token (parser->lexer)->type == CPP_COLON) - { - cp_lexer_consume_token (parser->lexer); - saved_colon_corrects_to_scope_p = - parser->colon_corrects_to_scope_p; - /* Disable correcting single colon correcting to scope. */ - parser->colon_corrects_to_scope_p = false; - stride = cp_parser_expression (parser, false, NULL); - parser->colon_corrects_to_scope_p = - saved_colon_corrects_to_scope_p; - if (!stride || stride == error_mark_node) - { - cp_parser_skip_to_end_of_statement (parser); - if (cp_lexer_peek_token (parser->lexer)->type - == CPP_CLOSE_SQUARE) - cp_lexer_consume_token (parser->lexer); - } - } - else - stride = build_one_cst (integer_type_node); + *init_index = cp_parser_expression (parser, false, NULL); + if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON) + { + /* This indicates that we have a normal array expression. */ + parser->colon_corrects_to_scope_p = saved_colon_corrects; + return NULL_TREE; } - else + + /* Consume the ':'. */ + cp_lexer_consume_token (parser->lexer); + length_index = cp_parser_expression (parser, false, NULL); + if (cp_lexer_peek_token (parser->lexer)->type == CPP_COLON) { - cp_parser_skip_to_end_of_statement (parser); - return error_mark_node; + cp_lexer_consume_token (parser->lexer); + stride = cp_parser_expression (parser, false, NULL); } } - - if (start_index == error_mark_node || length_index == error_mark_node - || stride == error_mark_node || !start_index || !length_index - || !stride) + parser->colon_corrects_to_scope_p = saved_colon_corrects; + + if (*init_index == error_mark_node || length_index == error_mark_node + || stride == error_mark_node) { if (cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_SQUARE) cp_lexer_consume_token (parser->lexer); return error_mark_node; } cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE); - - /* We fold all 3 of the values to make things easier when we transform - them later. */ - start_index = fold (start_index); - length_index = fold (length_index); - stride = fold (stride); - - value_tree = build_array_notation_ref (input_location, array_value, - start_index, length_index, stride, - type); + + value_tree = build_array_notation_ref (loc, array_value, *init_index, + length_index, stride, array_type); return value_tree; } @@ -6241,84 +6163,68 @@ cp_parser_postfix_open_square_expression (cp_parser *parser, bool for_offsetof, bool decltype_p) { - tree index; + tree index = NULL_TREE; location_t loc = cp_lexer_peek_token (parser->lexer)->location; /* Consume the `[' token. */ cp_lexer_consume_token (parser->lexer); - if (flag_enable_cilkplus - && cp_lexer_peek_token (parser->lexer)->type == CPP_COLON) - /* If we are here, then we have something like this: - ARRAY[:] - */ - postfix_expression = cp_parser_array_notation (loc, parser, NULL_TREE, - postfix_expression); + /* Parse the index expression. */ + /* ??? For offsetof, there is a question of what to allow here. If + offsetof is not being used in an integral constant expression context, + then we *could* get the right answer by computing the value at runtime. + If we are in an integral constant expression context, then we might + could accept any constant expression; hard to say without analysis. + Rather than open the barn door too wide right away, allow only integer + constant expressions here. */ + if (for_offsetof) + index = cp_parser_constant_expression (parser, false, NULL); else { - /* Here are have these options: - 1. ARRAY[EXPR] -- This is the normal array call. - 2. ARRAY[EXPR : EXPR] -- Array notation expr with default stride - of 1. - 3. ARRAY[EXPR : EXPR : EXPR] -- Array Notation with userdefined stride. - 4. Array[Braced List] -- This is handled by braced list. - */ - - /* Parse the index expression. */ - /* ??? For offsetof, there is a question of what to allow here. If - offsetof is not being used in an integral constant expression context, - then we *could* get the right answer by computing the value at runtime. - If we are in an integral constant expression context, then we might - could accept any constant expression; hard to say without analysis. - Rather than open the barn door too wide right away, allow only integer - constant expressions here. */ - if (for_offsetof) - index = cp_parser_constant_expression (parser, false, NULL); - else + if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) { - bool saved_colon_corrects_to_scope_p = - parser->colon_corrects_to_scope_p; - if (flag_enable_cilkplus) - parser->colon_corrects_to_scope_p = false; - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) + bool expr_nonconst_p; + maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS); + index = cp_parser_braced_list (parser, &expr_nonconst_p); + if (flag_enable_cilkplus + && cp_lexer_peek_token (parser->lexer)->type == CPP_COLON) { - bool expr_nonconst_p; - maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS); - index = cp_parser_braced_list (parser, &expr_nonconst_p); - if (flag_enable_cilkplus - && cp_lexer_peek_token (parser->lexer)->type == CPP_COLON) - { - error_at (cp_lexer_peek_token (parser->lexer)->location, - "braced list index is not allowed with array " - "notations"); - index = error_mark_node; - } + error_at (cp_lexer_peek_token (parser->lexer)->location, + "braced list index is not allowed with array " + "notation"); + cp_parser_skip_to_end_of_statement (parser); + return error_mark_node; } - else - index = cp_parser_expression (parser, /*cast_p=*/false, NULL); - parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p; } - if (flag_enable_cilkplus - && cp_lexer_peek_token (parser->lexer)->type == CPP_COLON) - postfix_expression = cp_parser_array_notation (loc, parser, index, - postfix_expression); - else + else if (flag_enable_cilkplus) { - /* Look for the closing `]'. */ - cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE); - - /* Build the ARRAY_REF. */ - postfix_expression = grok_array_decl (loc, postfix_expression, - index, decltype_p); - - /* When not doing offsetof, array references are not permitted in - constant-expressions. */ - if (!for_offsetof - && (cp_parser_non_integral_constant_expression (parser, - NIC_ARRAY_REF))) - postfix_expression = error_mark_node; + /* Here are have these two options: + ARRAY[EXP : EXP] - Array notation expr with default + stride of 1. + ARRAY[EXP : EXP : EXP] - Array Notation with user-defined + stride. */ + tree an_exp = cp_parser_array_notation (loc, parser, &index, + postfix_expression); + if (an_exp) + return an_exp; } + else + index = cp_parser_expression (parser, /*cast_p=*/false, NULL); } + + /* Look for the closing `]'. */ + cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE); + + /* Build the ARRAY_REF. */ + postfix_expression = grok_array_decl (loc, postfix_expression, + index, decltype_p); + + /* When not doing offsetof, array references are not permitted in + constant-expressions. */ + if (!for_offsetof + && (cp_parser_non_integral_constant_expression (parser, NIC_ARRAY_REF))) + postfix_expression = error_mark_node; + return postfix_expression; } @@ -9553,8 +9459,6 @@ cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr, /* Consume the `}'. */ cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE); - if (flag_enable_cilkplus && contains_array_notation_expr (compound_stmt)) - compound_stmt = expand_array_notation_exprs (compound_stmt); return compound_stmt; } @@ -9747,14 +9651,6 @@ cp_parser_selection_statement (cp_parser* parser, bool *if_p) /* Now we're all done with the switch-statement. */ finish_switch_stmt (statement); - if (flag_enable_cilkplus - && contains_array_notation_expr (condition)) - { - error_at (EXPR_LOCATION (condition), - "array notations cannot be used as a condition for " - "switch statement"); - statement = error_mark_node; - } } return statement; @@ -10312,12 +10208,6 @@ cp_parser_iteration_statement (cp_parser* parser) parser->in_statement = in_statement; /* We're done with the while-statement. */ finish_while_stmt (statement); - if (flag_enable_cilkplus && contains_array_notation_expr (condition)) - { - error_at (EXPR_LOCATION (condition), "array notations cannot be " - "used as a condition for while statement"); - statement = error_mark_node; - } } break; @@ -10344,15 +10234,6 @@ cp_parser_iteration_statement (cp_parser* parser) cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN); /* Look for the `;'. */ cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON); - if (flag_enable_cilkplus - && contains_array_notation_expr (DO_COND (statement))) - { - error_at (EXPR_LOCATION (DO_COND (statement)), - "array notations cannot be used as a condition for a " - "do-while statement"); - statement = error_mark_node; - } - } break; @@ -10371,17 +10252,8 @@ cp_parser_iteration_statement (cp_parser* parser) cp_parser_already_scoped_statement (parser); parser->in_statement = in_statement; - if (flag_enable_cilkplus - && contains_array_notation_expr (FOR_COND (statement))) - { - error_at (EXPR_LOCATION (FOR_COND (statement)), - "array notations cannot be used in a condition for a " - "for-loop"); - statement = error_mark_node; - } - else - /* We're done with the for-statement. */ - finish_for_stmt (statement); + /* We're done with the for-statement. */ + finish_for_stmt (statement); } break; @@ -16954,54 +16826,30 @@ cp_parser_direct_declarator (cp_parser* parser, if (token->type != CPP_CLOSE_SQUARE) { bool non_constant_p; - - if (flag_enable_cilkplus - && cp_lexer_next_token_is (parser->lexer, CPP_COLON)) + bounds + = cp_parser_constant_expression (parser, + /*allow_non_constant=*/true, + &non_constant_p); + if (!non_constant_p) + /* OK */; + else if (error_operand_p (bounds)) + /* Already gave an error. */; + else if (!parser->in_function_body + || current_binding_level->kind == sk_function_parms) { + /* Normally, the array bound must be an integral constant + expression. However, as an extension, we allow VLAs + in function scopes as long as they aren't part of a + parameter declaration. */ + cp_parser_error (parser, + "array bound is not an integer constant"); bounds = error_mark_node; - error_at (cp_lexer_peek_token (parser->lexer)->location, - "array notations cannot be used in declaration"); - cp_lexer_consume_token (parser->lexer); } - else + else if (processing_template_decl) { - bounds - = cp_parser_constant_expression (parser, - /*allow_non_constant=*/true, - &non_constant_p); - if (!non_constant_p) - /* OK */; - else if (error_operand_p (bounds)) - /* Already gave an error. */; - else if (!parser->in_function_body - || current_binding_level->kind == sk_function_parms) - { - /* Normally, the array bound must be an integral constant - expression. However, as an extension, we allow VLAs - in function scopes as long as they aren't part of a - parameter declaration. */ - cp_parser_error (parser, - "array bound is not an integer constant"); - bounds = error_mark_node; - } - else if (processing_template_decl) - { - /* Remember this wasn't a constant-expression. */ - bounds = build_nop (TREE_TYPE (bounds), bounds); - TREE_SIDE_EFFECTS (bounds) = 1; - } - if (flag_enable_cilkplus - && cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - { - location_t loc = - cp_lexer_peek_token (parser->lexer)->location; - while (cp_lexer_next_token_is_not (parser->lexer, - CPP_CLOSE_SQUARE)) - cp_lexer_consume_token (parser->lexer); - error_at (loc, "array notations cannot be used in " - "declaration"); - bounds = error_mark_node; - } + /* Remember this wasn't a constant-expression. */ + bounds = build_nop (TREE_TYPE (bounds), bounds); + TREE_SIDE_EFFECTS (bounds) = 1; } } else @@ -18372,11 +18220,6 @@ cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser, cp_parser_function_body (parser, in_function_try_block); if (check_body_p) check_constexpr_ctor_body (last, list); - - /* Transform all array notations to the equivalent array refs and loop. */ - if (flag_enable_cilkplus && contains_array_notation_expr (body)) - body = expand_array_notation_exprs (body); - /* Finish the function body. */ finish_function_body (body); @@ -22356,12 +22199,6 @@ cp_parser_function_definition_after_declarator (cp_parser* parser, finish_lambda_scope (); - /* Expand all array notation expressions here. */ - if (flag_enable_cilkplus && current_function_decl - && contains_array_notation_expr (DECL_SAVED_TREE (current_function_decl))) - DECL_SAVED_TREE (current_function_decl) = - expand_array_notation_exprs (DECL_SAVED_TREE (current_function_decl)); - /* Finish the function. */ fn = finish_function ((ctor_initializer_p ? 1 : 0) | (inline_p ? 2 : 0)); diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 4ab64c9..3847a1d 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -13762,9 +13762,6 @@ tsubst_copy_and_build (tree t, start_index = RECUR (ARRAY_NOTATION_START (t)); length = RECUR (ARRAY_NOTATION_LENGTH (t)); stride = RECUR (ARRAY_NOTATION_STRIDE (t)); - if (!cilkplus_an_triplet_types_ok_p (loc, start_index, length, stride, - TREE_TYPE (op1))) - RETURN (error_mark_node); RETURN (build_array_notation_ref (EXPR_LOCATION (t), op1, start_index, length, stride, TREE_TYPE (op1))); } @@ -15747,9 +15744,6 @@ type_unification_real (tree tparms, arg = args[ia]; ++ia; - if (flag_enable_cilkplus && TREE_CODE (arg) == ARRAY_NOTATION_REF) - return 1; - if (unify_one_argument (tparms, targs, parm, arg, subr, strict, flags, explain_p)) return 1; @@ -19170,11 +19164,6 @@ instantiate_decl (tree d, int defer_ok, pointer_map_destroy (local_specializations); local_specializations = saved_local_specializations; - /* We expand all the array notation expressions here. */ - if (flag_enable_cilkplus - && contains_array_notation_expr (DECL_SAVED_TREE (d))) - DECL_SAVED_TREE (d) = expand_array_notation_exprs (DECL_SAVED_TREE (d)); - /* Finish the function. */ d = finish_function (0); expand_or_defer_fn (d); diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 4c76b80..f821754 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -779,22 +779,6 @@ finish_return_stmt (tree expr) tree r; bool no_warning; - if (flag_enable_cilkplus && contains_array_notation_expr (expr)) - { - size_t rank = 0; - - if (!find_rank (input_location, expr, expr, false, &rank)) - return error_mark_node; - - /* If the return expression contains array notations, then flag it as - error. */ - if (rank >= 1) - { - error_at (input_location, "array notation expression cannot be " - "used as a return value"); - return error_mark_node; - } - } expr = check_return_expr (expr, &no_warning); if (flag_openmp && !check_omp_return ()) @@ -8089,7 +8073,6 @@ cxx_eval_constant_expression (const constexpr_call *call, tree t, non_constant_p, overflow_p); break; - case ARRAY_NOTATION_REF: case ARRAY_REF: r = cxx_eval_array_reference (call, t, allow_non_constant, addr, non_constant_p, overflow_p); @@ -8901,7 +8884,6 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags) want_rval = true; /* Fall through. */ case ARRAY_REF: - case ARRAY_NOTATION_REF: case ARRAY_RANGE_REF: case MEMBER_REF: case DOTSTAR_EXPR: @@ -8912,6 +8894,9 @@ potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags) return false; return true; + case ARRAY_NOTATION_REF: + return false; + case FMA_EXPR: case VEC_PERM_EXPR: for (i = 0; i < 3; ++i) diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 4a7f1f6..462abdd 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -3493,10 +3493,6 @@ cp_build_function_call_vec (tree function, vec **params, params = &allocated; } - if (flag_enable_cilkplus - && is_cilkplus_reduce_builtin (fndecl) != BUILT_IN_NONE) - nargs = (*params)->length (); - else nargs = convert_arguments (parm_types, params, fndecl, LOOKUP_NORMAL, complain); if (nargs < 0) @@ -3660,8 +3656,7 @@ convert_arguments (tree typelist, vec **values, tree fndecl, } else { - if (fndecl && DECL_BUILT_IN (fndecl) - && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P) + if (fndecl && magic_varargs_p (fndecl)) /* Don't do ellipsis conversion for __built_in_constant_p as this will result in spurious errors for non-trivial types. */ @@ -3956,15 +3951,8 @@ cp_build_binary_op (location_t location, } } - if (flag_enable_cilkplus && contains_array_notation_expr (op0)) - type0 = find_correct_array_notation_type (op0); - else - type0 = TREE_TYPE (op0); - - if (flag_enable_cilkplus && contains_array_notation_expr (op1)) - type1 = find_correct_array_notation_type (op1); - else - type1 = TREE_TYPE (op1); + type0 = TREE_TYPE (op0); + type1 = TREE_TYPE (op1); /* The expression codes of the data types of the arguments tell us whether the arguments are integers, floating, pointers, etc. */ @@ -5182,13 +5170,6 @@ cp_build_addr_expr_1 (tree arg, bool strict_lvalue, tsubst_flags_t complain) gcc_assert (!identifier_p (arg) || !IDENTIFIER_OPNAME_P (arg)); - if (flag_enable_cilkplus && TREE_CODE (arg) == ARRAY_NOTATION_REF) - { - val = build_address (arg); - if (TREE_CODE (arg) == OFFSET_REF) - PTRMEM_OK_P (val) = PTRMEM_OK_P (arg); - return val; - } if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg) && !really_overloaded_fn (TREE_OPERAND (arg, 1))) { @@ -7867,13 +7848,6 @@ convert_for_assignment (tree type, tree rhs, tree rhstype; enum tree_code coder; - /* If we are dealing with built-in array notation function then we don't need - to convert them. They will be broken up into modify exprs in future, - during which all these checks will be done. */ - if (flag_enable_cilkplus - && is_cilkplus_reduce_builtin (fndecl) != BUILT_IN_NONE) - return rhs; - /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ if (TREE_CODE (rhs) == NON_LVALUE_EXPR) rhs = TREE_OPERAND (rhs, 0); -- cgit v1.1