Binary files a/gcc/ChangeLog and b/gcc/ChangeLog differ
@@ -158,9 +158,9 @@ along with GCC; see the file COPYING3. If not see
(flag_asan || flag_tsan))
#undef DEF_CILKPLUS_BUILTIN
-#define DEF_CILKPLUS_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
- DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
- false, false, true, ATTRS, false, flag_enable_cilkplus)
+#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)
/* Define an attribute list for math functions that are normally
"impure" because some of them may write into global memory for
Binary files a/gcc/c-family/ChangeLog and b/gcc/c-family/ChangeLog differ
@@ -86,7 +86,6 @@ length_mismatch_in_expr_p (location_t loc, tree **list, size_t x, size_t y)
{
size_t ii, jj;
tree start = NULL_TREE;
- HOST_WIDE_INT l_start, l_node;
for (jj = 0; jj < y; jj++)
{
start = NULL_TREE;
@@ -99,15 +98,11 @@ length_mismatch_in_expr_p (location_t loc, tree **list, size_t x, size_t y)
/* If start is a INTEGER, and list[ii][jj] is an integer then
check if they are equal. If they are not equal then return
true. */
- if (TREE_CODE (list[ii][jj]) == INTEGER_CST)
- {
- l_node = int_cst_value (list[ii][jj]);
- l_start = int_cst_value (start);
- if (absu_hwi (l_start) != absu_hwi (l_node))
- {
- error_at (loc, "length mismatch in expression");
- return true;
- }
+ if (TREE_CODE (list[ii][jj]) == INTEGER_CST
+ && !tree_int_cst_equal (list[ii][jj], start))
+ {
+ error_at (loc, "length mismatch in expression");
+ return true;
}
}
else
@@ -269,6 +264,8 @@ find_rank (location_t loc, tree orig_expr, tree expr, bool ignore_builtin_fn,
/* If it is a built-in function, then we know it returns a
scalar. */
return true;
+ if (!find_rank (loc, orig_expr, func_name, ignore_builtin_fn, rank))
+ return false;
FOR_EACH_CALL_EXPR_ARG (arg, iter, expr)
{
if (!find_rank (loc, orig_expr, arg, ignore_builtin_fn, rank))
@@ -356,6 +353,9 @@ extract_array_notation_exprs (tree node, bool ignore_builtin_fn,
vec_safe_push (*array_list, node);
return;
}
+ /* This will extract array notations in function pointers. */
+ extract_array_notation_exprs (CALL_EXPR_FN (node), ignore_builtin_fn,
+ array_list);
FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
extract_array_notation_exprs (arg, ignore_builtin_fn, array_list);
}
@@ -431,6 +431,9 @@ replace_array_notations (tree *orig, bool ignore_builtin_fn,
}
return;
}
+ /* Fixes array notations in array notations in function pointers. */
+ replace_array_notations (&CALL_EXPR_FN (*orig), ignore_builtin_fn, list,
+ array_operand);
ii = 0;
FOR_EACH_CALL_EXPR_ARG (arg, iter, *orig)
{
@@ -573,53 +576,49 @@ cilkplus_extract_an_triplets (vec<tree, va_gc> *list, size_t size, size_t rank,
vec<vec<struct cilkplus_an_parts> > *node)
{
vec<vec<tree> > array_exprs = vNULL;
- struct cilkplus_an_parts init = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
- false };
+
node->safe_grow_cleared (size);
array_exprs.safe_grow_cleared (size);
- for (size_t ii = 0; ii < size; ii++)
- for (size_t jj = 0; jj < rank; jj++)
+
+ if (rank > 0)
+ for (size_t ii = 0; ii < size; ii++)
{
- (*node)[ii].safe_push (init);
- array_exprs[ii].safe_push (NULL_TREE);
+ (*node)[ii].safe_grow_cleared (rank);
+ array_exprs[ii].safe_grow_cleared (rank);
}
-
for (size_t ii = 0; ii < size; ii++)
{
size_t jj = 0;
tree ii_tree = (*list)[ii];
while (ii_tree)
- if (TREE_CODE (ii_tree) == ARRAY_NOTATION_REF)
- {
- array_exprs[ii][jj] = ii_tree;
- jj++;
- ii_tree = ARRAY_NOTATION_ARRAY (ii_tree);
- }
- else if (TREE_CODE (ii_tree) == ARRAY_REF)
- ii_tree = TREE_OPERAND (ii_tree, 0);
- else if (TREE_CODE (ii_tree) == VAR_DECL
- || TREE_CODE (ii_tree) == CALL_EXPR
- || TREE_CODE (ii_tree) == PARM_DECL)
- break;
- else
- gcc_unreachable ();
+ {
+ if (TREE_CODE (ii_tree) == ARRAY_NOTATION_REF)
+ {
+ array_exprs[ii][jj] = ii_tree;
+ jj++;
+ ii_tree = ARRAY_NOTATION_ARRAY (ii_tree);
+ }
+ else if (TREE_CODE (ii_tree) == ARRAY_REF)
+ ii_tree = TREE_OPERAND (ii_tree, 0);
+ else
+ break;
+ }
}
for (size_t ii = 0; ii < size; ii++)
if (TREE_CODE ((*list)[ii]) == ARRAY_NOTATION_REF)
for (size_t jj = 0; jj < rank; jj++)
- if (TREE_CODE (array_exprs[ii][jj]) == ARRAY_NOTATION_REF)
- {
- tree ii_tree = array_exprs[ii][jj];
- (*node)[ii][jj].is_vector = true;
- (*node)[ii][jj].value = ARRAY_NOTATION_ARRAY (ii_tree);
- (*node)[ii][jj].start = ARRAY_NOTATION_START (ii_tree);
- (*node)[ii][jj].length =
- fold_build1 (CONVERT_EXPR, integer_type_node,
- ARRAY_NOTATION_LENGTH (ii_tree));
- (*node)[ii][jj].stride =
- fold_build1 (CONVERT_EXPR, integer_type_node,
- ARRAY_NOTATION_STRIDE (ii_tree));
- }
+ {
+ tree ii_tree = array_exprs[ii][jj];
+ (*node)[ii][jj].is_vector = true;
+ (*node)[ii][jj].value = ARRAY_NOTATION_ARRAY (ii_tree);
+ (*node)[ii][jj].start = ARRAY_NOTATION_START (ii_tree);
+ (*node)[ii][jj].length =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_LENGTH (ii_tree));
+ (*node)[ii][jj].stride =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_STRIDE (ii_tree));
+ }
}
/* Replaces all the __sec_implicit_arg functions in LIST with the induction
@@ -635,16 +634,15 @@ fix_sec_implicit_args (location_t loc, vec <tree, va_gc> *list,
vec <tree, va_gc> *array_operand = NULL;
for (size_t ii = 0; ii < vec_safe_length (list); ii++)
if (TREE_CODE ((*list)[ii]) == CALL_EXPR
- && TREE_CODE (CALL_EXPR_FN ((*list)[ii])) == ADDR_EXPR
&& is_sec_implicit_index_fn (CALL_EXPR_FN ((*list)[ii])))
{
int idx = extract_sec_implicit_index_arg (loc, (*list)[ii]);
- if (idx < (int) rank && idx >= 0)
- vec_safe_push (array_operand, an_loop_info[idx].var);
- else if (idx == -1)
+ if (idx < 0)
/* In this case, the returning function would have emitted an
error thus it is not necessary to do so again. */
return NULL;
+ else if (idx < (int) rank)
+ vec_safe_push (array_operand, an_loop_info[idx].var);
else
{
error_at (loc, "__sec_implicit_index argument %d must be "
Binary files a/gcc/c/ChangeLog and b/gcc/c/ChangeLog differ
@@ -11053,24 +11053,6 @@ c_parser_array_notation (location_t loc, c_parser *parser, tree initial_index,
c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
return error_mark_node;
}
- if (TREE_CODE (array_type) == ARRAY_TYPE)
- {
- tree subtype = TREE_TYPE (array_type);
- while (subtype && TREE_CODE (subtype) == POINTER_TYPE)
- {
- /* Now this could be a function pointer. Find them and
- give out an error. */
- subtype = TREE_TYPE (subtype);
- if (subtype && TREE_CODE (subtype) == FUNCTION_TYPE)
- {
- error_at (loc, "array notations cannot be used with "
- "function pointer arrays");
- c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
- NULL);
- return error_mark_node;
- }
- }
- }
array_type_domain = TYPE_DOMAIN (array_type);
if (!array_type_domain)
@@ -11114,27 +11096,6 @@ c_parser_array_notation (location_t loc, c_parser *parser, tree initial_index,
c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
return error_mark_node;
}
- if (TREE_CODE (array_type) == ARRAY_TYPE
- || TREE_CODE (array_type) == POINTER_TYPE)
- {
- tree subtype = TREE_TYPE (array_type);
- while (subtype
- && (TREE_CODE (subtype) == POINTER_TYPE
- || TREE_CODE (subtype) == ARRAY_TYPE))
- {
- /* Now this could be a function pointer. Find them and
- give out an error. */
- subtype = TREE_TYPE (subtype);
- if (subtype && TREE_CODE (subtype) == FUNCTION_TYPE)
- {
- error_at (loc, "array notations cannot be used with "
- "function pointer arrays");
- c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
- NULL);
- return error_mark_node;
- }
- }
- }
c_parser_consume_token (parser); /* consume the ':' */
end_index = c_parser_expression (parser).value;
if (!end_index || end_index == error_mark_node)
Binary files a/gcc/cp/ChangeLog and b/gcc/cp/ChangeLog differ
@@ -5857,16 +5857,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);
@@ -6518,6 +6511,9 @@ convert_for_arg_passing (tree type, tree val, tsubst_flags_t complain)
static 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 +6891,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
@@ -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. */
@@ -79,7 +78,7 @@ create_an_loop (tree init, tree cond, tree incr, tree body)
}
/* Returns true if there is a length mismatch among exprssions that are at the
- same dimension and one the same side of the equal sign. The Array notation
+ same dimension and on the same side of the equal sign. The Array notation
lengths (LIST->LENGTH) is passed in as a 2D vector of trees. */
static bool
@@ -87,14 +86,13 @@ cp_length_mismatch_in_expr_p (location_t loc, vec<vec<an_parts> >list)
{
size_t ii, jj;
tree length = NULL_TREE;
- HOST_WIDE_INT l_length, l_node;
size_t x = list.length ();
- size_t y = list[0].length ();
-
+ size_t y = list[0].length ();
+
for (jj = 0; jj < y; jj++)
{
- length = NULL_TREE;
+ length = NULL_TREE;
for (ii = 0; ii < x; ii++)
{
if (!length)
@@ -104,20 +102,16 @@ cp_length_mismatch_in_expr_p (location_t loc, vec<vec<an_parts> >list)
/* If length is a INTEGER, and list[ii][jj] is an integer then
check if they are equal. If they are not equal then return
true. */
- if (TREE_CODE (list[ii][jj].length) == INTEGER_CST)
- {
- l_node = int_cst_value (list[ii][jj].length);
- l_length = int_cst_value (length);
- if (absu_hwi (l_length) != absu_hwi (l_node))
- {
- error_at (loc, "length mismatch in expression");
- return true;
- }
+ if (TREE_CODE (list[ii][jj].length) == INTEGER_CST
+ && !tree_int_cst_equal (list[ii][jj].length, length))
+ {
+ error_at (loc, "length mismatch in expression");
+ return true;
}
}
else
- /* We set the length node as the current node just in case it turns
- out to be an integer. */
+ /* We set the list[ii][jj].length as the current node just in case
+ it turns out to be an integer. */
length = list[ii][jj].length;
}
}
@@ -128,17 +122,12 @@ cp_length_mismatch_in_expr_p (location_t loc, vec<vec<an_parts> >list)
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 (integer_type_node, *value);
}
/* Returns a vector of size RANK that contains an ARRAY_REF. This vector is
@@ -238,7 +227,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;
@@ -250,17 +239,8 @@ 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);
+ {
+ 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);
@@ -281,7 +261,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<tree, va_gc> *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 ();
@@ -351,7 +330,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:
@@ -380,24 +359,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);
@@ -406,26 +391,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)
@@ -440,35 +408,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;
@@ -479,9 +448,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:
@@ -516,8 +487,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,
@@ -567,21 +536,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++)
@@ -591,7 +547,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 ();
@@ -680,10 +636,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
@@ -705,8 +658,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;
}
@@ -721,17 +672,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);
@@ -751,10 +702,10 @@ 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)
@@ -768,14 +719,16 @@ expand_an_in_modify_expr (location_t location, tree lhs,
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,
@@ -789,24 +742,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)
@@ -860,7 +804,7 @@ expand_an_in_modify_expr (location_t location, tree 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++)
{
@@ -870,17 +814,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);
@@ -913,7 +853,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<vec<an_parts> > an_info = vNULL;
vec<an_loop_parts> an_loop_info = vNULL;
@@ -995,11 +934,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))
@@ -1023,37 +962,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++)
@@ -1063,7 +993,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 ();
@@ -1108,14 +1038,14 @@ expand_unary_array_notation_exprs (tree orig_stmt)
{
vec<tree, va_gc> *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;
@@ -1135,22 +1065,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,
@@ -1159,7 +1086,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++)
@@ -1169,7 +1096,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 ();
@@ -1190,16 +1117,18 @@ expand_return_expr (tree expr)
return expr;
location_t loc = EXPR_LOCATION (expr);
- new_mod_list = alloc_stmt_list ();
+ 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 = get_temp_regvar (TREE_TYPE (retval_expr),
+ build_zero_cst (TREE_TYPE (retval_expr)));
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;
}
@@ -1336,19 +1265,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;
@@ -1368,6 +1299,13 @@ expand_array_notation_exprs (tree t)
t = expand_array_notation_exprs (t);
return t;
case SWITCH_STMT:
+ if (contains_array_notation_expr (SWITCH_STMT_COND (t)))
+ {
+ error_at (EXPR_LOCATION (SWITCH_STMT_COND (t)),
+ "array notation cannot be used as a condition for "
+ "switch statement");
+ return error_mark_node;
+ }
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
@@ -1382,6 +1320,14 @@ expand_array_notation_exprs (tree t)
t = expand_array_notation_exprs (t);
return t;
case WHILE_STMT:
+ if (contains_array_notation_expr (WHILE_COND (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;
+ }
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
@@ -1395,6 +1341,13 @@ expand_array_notation_exprs (tree t)
t = expand_array_notation_exprs (t);
return t;
case DO_STMT:
+ 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;
+ }
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
@@ -1508,20 +1461,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))
@@ -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));
@@ -6062,10 +6062,10 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
/* 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
+ INIT_INDEX is NULL, then we have special case where 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. */
+ 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,
@@ -6074,8 +6074,6 @@ cp_parser_array_notation (location_t loc, cp_parser *parser, tree init_index,
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;
if (!array_value || array_value == error_mark_node)
{
@@ -6117,44 +6115,24 @@ cp_parser_array_notation (location_t loc, cp_parser *parser, tree init_index,
|| TREE_CODE (array_type) == POINTER_TYPE)
{
error_at (loc, "start-index and length fields necessary for "
- "using array notations in pointers or records");
+ "using array notation 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");
+ "using array notation with array of unknown bound");
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);
+ start_index = cp_fold_convert (ptrdiff_type_node, start_index);
+ length_index = size_binop
+ (PLUS_EXPR, TYPE_MAXVAL (array_type_domain), size_one_node);
+ length_index = cp_fold_convert (ptrdiff_type_node, length_index);
+ stride = build_int_cst (ptrdiff_type_node, 1);
}
else if (init_index != error_mark_node)
{
@@ -6165,12 +6143,12 @@ cp_parser_array_notation (location_t loc, cp_parser *parser, tree init_index,
start_index = init_index;
cp_lexer_consume_token (parser->lexer);
- saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
+ bool 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);
@@ -6180,7 +6158,6 @@ cp_parser_array_notation (location_t loc, cp_parser *parser, tree init_index,
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;
@@ -6211,13 +6188,7 @@ cp_parser_array_notation (location_t loc, cp_parser *parser, tree init_index,
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);
@@ -6248,8 +6219,7 @@ cp_parser_postfix_open_square_expression (cp_parser *parser,
if (flag_enable_cilkplus
&& cp_lexer_peek_token (parser->lexer)->type == CPP_COLON)
/* If we are here, then we have something like this:
- ARRAY[:]
- */
+ ARRAY[:] */
postfix_expression = cp_parser_array_notation (loc, parser, NULL_TREE,
postfix_expression);
else
@@ -6259,8 +6229,7 @@ cp_parser_postfix_open_square_expression (cp_parser *parser,
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.
- */
+ 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
@@ -6288,7 +6257,7 @@ cp_parser_postfix_open_square_expression (cp_parser *parser,
{
error_at (cp_lexer_peek_token (parser->lexer)->location,
"braced list index is not allowed with array "
- "notations");
+ "notation");
index = error_mark_node;
}
}
@@ -9550,9 +9519,6 @@ cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
finish_compound_stmt (compound_stmt);
/* 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;
}
@@ -9745,14 +9711,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;
@@ -10310,12 +10268,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;
@@ -10342,15 +10294,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;
@@ -10367,19 +10310,10 @@ cp_parser_iteration_statement (cp_parser* parser)
/* Parse the body of the for-statement. */
parser->in_statement = IN_ITERATION_STMT;
cp_parser_already_scoped_statement (parser);
- parser->in_statement = in_statement;
+ 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;
@@ -16953,54 +16887,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,10 +18282,6 @@ cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser,
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);
@@ -22355,12 +22261,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));
@@ -15739,9 +15739,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;
@@ -19143,11 +19140,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);
@@ -8089,7 +8089,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 +8900,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 +8910,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)
Binary files a/gcc/testsuite/ChangeLog and b/gcc/testsuite/ChangeLog differ
@@ -1,3 +1,4 @@
+/* { dg-do compile { target c } } */
/* { dg-options "-fcilkplus" } */
int main(void)
@@ -5,6 +5,6 @@ extern int *b;
void foo()
{
- a[:] = 5; // { dg-error "start-index and length fields necessary for using array notations in dimensionless arrays" }
- b[:] = 5; // { dg-error "start-index and length fields necessary for using array notations in pointers" }
+ a[:] = 5; // { dg-error "start-index and length fields necessary for using array notation" }
+ b[:] = 5; // { dg-error "start-index and length fields necessary for using" }
}
@@ -1,3 +1,4 @@
+/* { dg-do compile } */
/* { dg-options "-fcilkplus" } */
typedef int (*foo)(int);
@@ -10,11 +11,11 @@ int main(void)
foo ***func_array_ptr;
int argc = 5;
- array[:] = func_array[:](10); /* { dg-error "array notations cannot be used with function pointer arrays" } */
- func_array[0:5](10); /* { dg-error "array notations cannot be used with function pointer arrays" } */
- func_array2[0:5][:](10); /* { dg-error "array notations cannot be used with function pointer arrays" } */
- array2[0:5][:] = func_array2[0:5][:](10); /* { dg-error "array notations cannot be used with function pointer arrays" } */
- func_array_ptr[0:5][0:4][0:argc:2](argc); /* { dg-error "array notations cannot be used with function pointer arrays" } */
+ array[:] = func_array[:](10);
+ func_array[0:5](10);
+ func_array2[0:5][:](10);
+ array2[0:5][:] = func_array2[0:5][:](10);
+ func_array_ptr[0:5][0:4][0:argc:2](argc);
return 0;
}
@@ -6,7 +6,7 @@ int main (void)
int array[10], array2[10][10];
int x, ii, jj ;
- switch (array[:]) { /* { dg-error "array notations cannot be used as a condition for switch statement" } */
+ switch (array[:]) { /* { dg-error "cannot be used as a condition for switch statement" } */
case 1:
x = 5;
break;
@@ -17,7 +17,7 @@ int main (void)
x = 9;
}
- switch (array2[:][:]) { /* { dg-error "array notations cannot be used as a condition for switch statement" } */
+ switch (array2[:][:]) { /* { dg-error "cannot be used as a condition for switch statement" } */
case 1:
x = 5;
break;
@@ -28,7 +28,7 @@ int main (void)
x = 9;
}
- switch (array[:] + x) { /* { dg-error "array notations cannot be used as a condition for switch statement" } */
+ switch (array[:] + x) { /* { dg-error "cannot be used as a condition for switch statement" } */
case 1:
x = 5;
break;
@@ -39,7 +39,7 @@ int main (void)
x = 9;
}
- switch (array2[:][1:x:4] + x) { /* { dg-error "array notations cannot be used as a condition for switch statement" } */
+ switch (array2[:][1:x:4] + x) { /* { dg-error "cannot be used as a condition for switch statement" } */
case 1:
x = 5;
break;
@@ -50,36 +50,36 @@ int main (void)
x = 9;
}
- for (ii = 0; ii < array[:]; ii++) /* { dg-error "array notations cannot be used in a condition for a for-loop" } */
+ for (ii = 0; ii < array[:]; ii++) /* { dg-error "cannot be used in a condition for a for-loop" } */
{
x = 2;
}
- for (ii = 0; ii < array2[:][:]; ii++) /* { dg-error "array notations cannot be used in a condition for a for-loop" } */
+ for (ii = 0; ii < array2[:][:]; ii++) /* { dg-error "cannot be used in a condition for a for-loop" } */
{
x = 3;
}
- for (; array2[:][:] < 2;) /* { dg-error "array notations cannot be used in a condition for a for-loop" } */
+ for (; array2[:][:] < 2;) /* { dg-error "cannot be used in a condition for a for-loop" } */
x = 4;
- while (array2[:][:]) /* { dg-error "array notations cannot be used as a condition for while statement" } */
+ while (array2[:][:]) /* { dg-error "cannot be used as a condition for while statement" } */
x = 3;
- while (array[1:1:1]) /* { dg-error "array notations cannot be used as a condition for while statement" } */
+ while (array[1:1:1]) /* { dg-error "cannot be used as a condition for while statement" } */
x = 1;
- while (ii != array2[1:x:3][1:2:1]) /* { dg-error "array notations cannot be used as a condition for while statement" } */
+ while (ii != array2[1:x:3][1:2:1]) /* { dg-error "cannot be used as a condition for while statement" } */
x = 2;
- do { /* { dg-error "array notations cannot be used as a condition for a do-while statement" "" { target c } } */
+ do { /* { dg-error "cannot be used as a condition for a do-while statement" "" { target c } } */
x = 3;
- } while (ii != array2[:][:]); /* { dg-error "array notations cannot be used as a condition for a do-while statement" "" { target c++ } } */
+ } while (ii != array2[:][:]); /* { dg-error "cannot be used as a condition for a do-while statement" "" { target c++ } } */
- do { /* { dg-error "array notations cannot be used as a condition for a do-while statement" "" { target c } } */
+ do { /* { dg-error "cannot be used as a condition for a do-while statement" "" { target c } } */
x = 2;
- } while (ii != (x + array2[:][1:x:2]) + 2); /* { dg-error "array notations cannot be used as a condition for a do-while statement" "" { target c++ } } */
+ } while (ii != (x + array2[:][1:x:2]) + 2); /* { dg-error "cannot be used as a condition for a do-while statement" "" { target c++ } } */
do {
x += 3;
@@ -10,6 +10,7 @@ int main (void)
int array[10][10], array2[10];
array[:][:] = array[:]; /* { dg-error "rank mismatch between" } */
+ /* { dg-error "invalid conversion" "" { target c++ } 12 } */
x = array2[:]; /* { dg-error "cannot be scalar when" } */