--- /dev/null
+/* This file is part of the Intel(R) Cilk(TM) Plus support
+ This file contains routines to handle Array Notation expression
+ handling routines in the C Compiler.
+ Copyright (C) 2013 Free Software Foundation, Inc.
+ Contributed by Balaji V. Iyer <balaji.v.iyer@intel.com>,
+ Intel Corporation.
+
+ This file is part of GCC.
+
+ GCC is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ GCC is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GCC; see the file COPYING3. If not see
+ <http://www.gnu.org/licenses/>. */
+
+/* The Array Notation Transformation Technique:
+
+ An array notation expression has 4 major components:
+ 1. The array name
+ 2. Start Index
+ 3. Number of elements we need to acess (we call it length)
+ 4. Stride
+
+ For example, A[0:5:2], implies that we are accessing A[0], A[2], A[4],
+ A[6] and A[8]. The user is responsible to make sure the access length does
+ not step outside the array's size.
+
+ In this section, I highlight the overall method on how array notations are
+ broken up into C/C++ code. Almost all the functions follows this overall
+ technique:
+
+ Let's say we have an array notation in a statement like this:
+
+ A[St1:Ln:Str1] = B[St2:Ln:Str2] + <NON ARRAY_NOTATION_STMT>
+
+ where St{1,2} = Starting index,
+ Ln = Number of elements we need to access,
+ and Str{1,2} = the stride.
+ Note: The length of both the array notation expressions must be the same.
+
+ The above expression is broken into the following
+ (with the help of c_finish_loop function from c-typeck.c):
+
+ Tmp_Var = 0;
+ goto compare_label:
+ body_label:
+
+ A[St1+Tmp_Var*Str1] = B[St1+Tmp_Var*Str2] + <NON ARRAY_NOTATION_STMT>;
+ Tmp_Var++;
+
+ compare_label:
+ if (Tmp_Var < Ln)
+ goto body_label;
+ else
+ goto exit_label;
+ exit_label:
+
+*/
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "c-tree.h"
+#include "tree-iterator.h"
+#include "opts.h"
+#include "c-family/c-common.h"
+
+static void replace_array_notations (tree *, bool, vec<tree, va_gc> *,
+ vec<tree, va_gc> *);
+static void extract_array_notation_exprs (tree, bool, vec<tree, va_gc> **);
+
+/* This structure holds all the scalar values and its appropriate variable
+ replacment. It is mainly used by the function that pulls all the invariant
+ parts that should be executed only once, which comes with array notation
+ expressions. */
+struct inv_list
+{
+ vec<tree, va_gc> *list_values;
+ vec<tree, va_gc> *replacement;
+};
+
+/* Returns true if there is length mismatch among expressions
+ on the same dimension and on the same side of the equal sign. The
+ expressions (or ARRAY_NOTATION lengths) are passed in through 2-D array
+ **LIST where X and Y indicate first and second dimension sizes of LIST,
+ respectively. */
+
+static bool
+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;
+ for (ii = 0; ii < x; ii++)
+ {
+ if (!start)
+ start = list[ii][jj];
+ else if (TREE_CODE (start) == INTEGER_CST)
+ {
+ /* 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 (abs (l_start) != abs (l_node))
+ {
+ error_at (loc, "length mismatch in expression");
+ return true;
+ }
+ }
+ }
+ else
+ /* We set the start node as the current node just in case it turns
+ out to be an integer. */
+ start = list[ii][jj];
+ }
+ }
+ return false;
+}
+
+
+/* Given an FNDECL of type FUNCTION_DECL or ADDR_EXPR, return the corresponding
+ BUILT_IN_CILKPLUS_SEC_REDUCE_* being called. If none, return
+ BUILT_IN_NONE. */
+
+enum built_in_function
+is_cilkplus_reduce_builtin (tree fndecl)
+{
+ if (TREE_CODE (fndecl) == ADDR_EXPR)
+ fndecl = TREE_OPERAND (fndecl, 0);
+
+ if (TREE_CODE (fndecl) == FUNCTION_DECL
+ && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
+ switch (DECL_FUNCTION_CODE (fndecl))
+ {
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ADD:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MUL:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING:
+ return DECL_FUNCTION_CODE (fndecl);
+ default:
+ break;
+ }
+
+ return BUILT_IN_NONE;
+}
+
+/* This function will recurse into EXPR finding any
+ ARRAY_NOTATION_EXPRs and calculate the overall rank of EXPR,
+ storing it in *RANK. LOC is the location of the original expression.
+
+ ORIG_EXPR is the original expression used to display if any rank
+ mismatch errors are found.
+
+ Upon entry, *RANK must be either 0, or the rank of a parent
+ expression that must have the same rank as the one being
+ calculated. It is illegal to have multiple array notation with different
+ rank in the same expression (see examples below for clarification).
+
+ If there were any rank mismatches while calculating the rank, an
+ error will be issued, and FALSE will be returned. Otherwise, TRUE
+ is returned.
+
+ If IGNORE_BUILTIN_FN is TRUE, ignore array notation specific
+ built-in functions (__sec_reduce_*, etc).
+
+ Here are some examples of array notations and their rank:
+
+ Expression RANK
+ 5 0
+ X (a variable) 0
+ *Y (a pointer) 0
+ A[5] 0
+ B[5][10] 0
+ A[:] 1
+ B[0:10] 1
+ C[0:10:2] 1
+ D[5][0:10:2] 1 (since D[5] is considered "scalar")
+ D[5][:][10] 1
+ E[:] + 5 1
+ F[:][:][:] + 5 + X 3
+ F[:][:][:] + E[:] + 5 + X RANKMISMATCH-ERROR since rank (E[:]) = 1 and
+ rank (F[:][:][:]) = 3. They must be equal
+ or have a rank of zero.
+ F[:][5][10] + E[:] * 5 + *Y 1
+
+ int func (int);
+ func (A[:]) 1
+ func (B[:][:][:][:]) 4
+
+ int func2 (int, int)
+ func2 (A[:], B[:][:][:][:]) RANKMISMATCH-ERROR -- Since Rank (A[:]) = 1
+ and Rank (B[:][:][:][:]) = 4
+
+ A[:] + func (B[:][:][:][:]) RANKMISMATCH-ERROR
+ func2 (A[:], B[:]) + func (A) 1
+
+ */
+
+bool
+find_rank (location_t loc, tree orig_expr, tree expr, bool ignore_builtin_fn,
+ size_t *rank)
+{
+ tree ii_tree;
+ size_t ii = 0, current_rank = 0;
+
+ if (TREE_CODE (expr) == ARRAY_NOTATION_REF)
+ {
+ ii_tree = expr;
+ while (ii_tree)
+ {
+ if (TREE_CODE (ii_tree) == ARRAY_NOTATION_REF)
+ {
+ current_rank++;
+ 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) == PARM_DECL
+ || TREE_CODE (ii_tree) == VAR_DECL)
+ break;
+ }
+ if (*rank == 0)
+ /* In this case, all the expressions this function has encountered thus
+ far have been scalars or expressions with zero rank. Please see
+ header comment for examples of such expression. */
+ *rank = current_rank;
+ else if (*rank != current_rank)
+ {
+ /* In this case, find rank is being recursed through a set of
+ expression of the form A <OPERATION> B, where A and B both have
+ array notations in them and the rank of A is not equal to rank of
+ B.
+ A simple example of such case is the following: X[:] + Y[:][:] */
+ *rank = current_rank;
+ return false;
+ }
+ }
+ else if (TREE_CODE (expr) == STATEMENT_LIST)
+ {
+ tree_stmt_iterator ii_tsi;
+ for (ii_tsi = tsi_start (expr); !tsi_end_p (ii_tsi);
+ tsi_next (&ii_tsi))
+ if (!find_rank (loc, orig_expr, *tsi_stmt_ptr (ii_tsi),
+ ignore_builtin_fn, rank))
+ return false;
+ }
+ else
+ {
+ if (TREE_CODE (expr) == CALL_EXPR)
+ {
+ tree func_name = CALL_EXPR_FN (expr);
+ tree prev_arg = NULL_TREE, arg;
+ call_expr_arg_iterator iter;
+ size_t prev_rank = 0;
+ if (TREE_CODE (func_name) == ADDR_EXPR)
+ if (!ignore_builtin_fn)
+ if (is_cilkplus_reduce_builtin (func_name))
+ /* If it is a built-in function, then we know it returns a
+ scalar. */
+ return true;
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, expr)
+ {
+ if (!find_rank (loc, orig_expr, arg, ignore_builtin_fn, rank))
+ {
+ if (prev_arg && EXPR_HAS_LOCATION (prev_arg)
+ && prev_rank != *rank)
+ error_at (EXPR_LOCATION (prev_arg),
+ "rank mismatch between %qE and %qE", prev_arg,
+ arg);
+ else if (prev_arg && prev_rank != *rank)
+ /* Here the original expression is printed as a "heads-up"
+ to the programmer. This is because since there is no
+ location information for the offending argument, the
+ error could be in some internally generated code that is
+ not visible for the programmer. Thus, the correct fix
+ may lie in the original expression. */
+ error_at (loc, "rank mismatch in expression %qE",
+ orig_expr);
+ return false;
+ }
+ prev_arg = arg;
+ prev_rank = *rank;
+ }
+ }
+ else
+ {
+ tree prev_arg = NULL_TREE;
+ for (ii = 0; ii < TREE_CODE_LENGTH (TREE_CODE (expr)); ii++)
+ {
+ if (TREE_OPERAND (expr, ii)
+ && !find_rank (loc, orig_expr, TREE_OPERAND (expr, ii),
+ ignore_builtin_fn, rank))
+ {
+ if (prev_arg && EXPR_HAS_LOCATION (prev_arg))
+ error_at (EXPR_LOCATION (prev_arg),
+ "rank mismatch between %qE and %qE", prev_arg,
+ TREE_OPERAND (expr, ii));
+ else if (prev_arg)
+ error_at (loc, "rank mismatch in expression %qE",
+ orig_expr);
+ return false;
+ }
+ prev_arg = TREE_OPERAND (expr, ii);
+ }
+ }
+ }
+ return true;
+}
+
+/* Extracts all array notations in NODE and stores them in ARRAY_LIST. If
+ IGNORE_BUILTIN_FN is set, then array notations inside array notation
+ specific built-in functions are ignored. The NODE can be constants,
+ VAR_DECL, PARM_DECLS, STATEMENT_LISTS or full expressions. */
+
+static void
+extract_array_notation_exprs (tree node, bool ignore_builtin_fn,
+ vec<tree, va_gc> **array_list)
+{
+ size_t ii = 0;
+ if (TREE_CODE (node) == ARRAY_NOTATION_REF)
+ {
+ vec_safe_push (*array_list, node);
+ return;
+ }
+ else if (TREE_CODE (node) == STATEMENT_LIST)
+ {
+ tree_stmt_iterator ii_tsi;
+ for (ii_tsi = tsi_start (node); !tsi_end_p (ii_tsi); tsi_next (&ii_tsi))
+ extract_array_notation_exprs (*tsi_stmt_ptr (ii_tsi),
+ ignore_builtin_fn, array_list);
+ }
+ else if (TREE_CODE (node) == CALL_EXPR)
+ {
+ tree arg;
+ call_expr_arg_iterator iter;
+ if (is_cilkplus_reduce_builtin (CALL_EXPR_FN (node)))
+ {
+ if (ignore_builtin_fn)
+ return;
+ else
+ {
+ vec_safe_push (*array_list, node);
+ return;
+ }
+ }
+ if (is_sec_implicit_index_fn (CALL_EXPR_FN (node)))
+ {
+ vec_safe_push (*array_list, node);
+ return;
+ }
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
+ extract_array_notation_exprs (arg, ignore_builtin_fn, array_list);
+ }
+ else
+ for (ii = 0; ii < TREE_CODE_LENGTH (TREE_CODE (node)); ii++)
+ if (TREE_OPERAND (node, ii))
+ extract_array_notation_exprs (TREE_OPERAND (node, ii),
+ ignore_builtin_fn, array_list);
+ return;
+}
+
+/* LIST contains all the array notations found in *ORIG and ARRAY_OPERAND
+ contains the expanded ARRAY_REF. E.g., if LIST[<some_index>] contains
+ an array_notation expression, then ARRAY_OPERAND[<some_index>] contains its
+ expansion. If *ORIG matches LIST[<some_index>] then *ORIG is set to
+ ARRAY_OPERAND[<some_index>]. This function recursively steps through
+ all the sub-trees of *ORIG, if it is larger than a single
+ ARRAY_NOTATION_REF. */
+
+static void
+replace_array_notations (tree *orig, bool ignore_builtin_fn,
+ vec<tree, va_gc> *list,
+ vec<tree, va_gc> *array_operand)
+{
+ size_t ii = 0;
+ tree node = NULL_TREE, node_replacement = NULL_TREE;
+
+ if (vec_safe_length (list) == 0)
+ return;
+
+ if (TREE_CODE (*orig) == ARRAY_NOTATION_REF)
+ {
+ for (ii = 0; vec_safe_iterate (list, ii, &node); ii++)
+ if (*orig == node)
+ {
+ node_replacement = (*array_operand)[ii];
+ *orig = node_replacement;
+ }
+ }
+ else if (TREE_CODE (*orig) == STATEMENT_LIST)
+ {
+ tree_stmt_iterator ii_tsi;
+ for (ii_tsi = tsi_start (*orig); !tsi_end_p (ii_tsi); tsi_next (&ii_tsi))
+ replace_array_notations (tsi_stmt_ptr (ii_tsi), ignore_builtin_fn, list,
+ array_operand);
+ }
+ else if (TREE_CODE (*orig) == CALL_EXPR)
+ {
+ tree arg;
+ call_expr_arg_iterator iter;
+ if (is_cilkplus_reduce_builtin (CALL_EXPR_FN (*orig)))
+ {
+ if (!ignore_builtin_fn)
+ {
+ for (ii = 0; vec_safe_iterate (list, ii, &node); ii++)
+ if (*orig == node)
+ {
+ node_replacement = (*array_operand)[ii];
+ *orig = node_replacement;
+ }
+ }
+ return;
+ }
+ if (is_sec_implicit_index_fn (CALL_EXPR_FN (*orig)))
+ {
+ for (ii = 0; vec_safe_iterate (list, ii, &node); ii++)
+ if (*orig == node)
+ {
+ node_replacement = (*array_operand)[ii];
+ *orig = node_replacement;
+ }
+ return;
+ }
+ ii = 0;
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, *orig)
+ {
+ replace_array_notations (&arg, ignore_builtin_fn, list,
+ array_operand);
+ CALL_EXPR_ARG (*orig, ii) = arg;
+ ii++;
+ }
+ }
+ else
+ {
+ for (ii = 0; ii < (size_t) TREE_CODE_LENGTH (TREE_CODE (*orig)); ii++)
+ if (TREE_OPERAND (*orig, ii))
+ replace_array_notations (&TREE_OPERAND (*orig, ii), ignore_builtin_fn,
+ list, array_operand);
+ }
+ return;
+}
+
+/* Callback for walk_tree. Find all the scalar expressions in *TP and push
+ them in DATA struct, typecasted to (void *). If *WALK_SUBTREES is set to 0
+ then do not go into the *TP's subtrees. Since this function steps through
+ all the subtrees, *TP and TP can be NULL_TREE and NULL, respectively. The
+ function returns NULL_TREE unconditionally. */
+
+static tree
+find_inv_trees (tree *tp, int *walk_subtrees, void *data)
+{
+ struct inv_list *i_list = (struct inv_list *) data;
+
+ if (!tp || !*tp)
+ return NULL_TREE;
+ if (TREE_CONSTANT (*tp))
+ return NULL_TREE; /* No need to save constant to a variable. */
+ if (TREE_CODE (*tp) != COMPOUND_EXPR && !contains_array_notation_expr (*tp))
+ {
+ vec_safe_push (i_list->list_values, *tp);
+ *walk_subtrees = 0;
+ }
+ else if (TREE_CODE (*tp) == ARRAY_NOTATION_REF
+ || TREE_CODE (*tp) == ARRAY_REF
+ || TREE_CODE (*tp) == CALL_EXPR)
+ /* No need to step through the internals of array notation. */
+ *walk_subtrees = 0;
+ else
+ *walk_subtrees = 1;
+ return NULL_TREE;
+}
+
+/* Callback for walk_tree. Replace all the scalar expressions in *TP with the
+ appropriate replacement stored in the struct *DATA (typecasted to void*).
+ The subtrees are not touched if *WALK_SUBTREES is set to zero. */
+
+static tree
+replace_inv_trees (tree *tp, int *walk_subtrees, void *data)
+{
+ size_t ii = 0;
+ tree t, r;
+ struct inv_list *i_list = (struct inv_list *) data;
+
+ if (vec_safe_length (i_list->list_values))
+ {
+ for (ii = 0; vec_safe_iterate (i_list->list_values, ii, &t); ii++)
+ if (simple_cst_equal (*tp, t) == 1)
+ {
+ vec_safe_iterate (i_list->replacement, ii, &r);
+ gcc_assert (r != NULL_TREE);
+ *tp = r;
+ *walk_subtrees = 0;
+ }
+ }
+ else
+ *walk_subtrees = 0;
+ return NULL_TREE;
+}
+
+/* Replaces all the scalar expressions in *NODE. Returns a STATEMENT_LIST that
+ holds the NODE along with variables that holds the results of the invariant
+ expressions. */
+
+tree
+replace_invariant_exprs (tree *node)
+{
+ size_t ix = 0;
+ tree node_list = NULL_TREE;
+ tree t = NULL_TREE, new_var = NULL_TREE, new_node;
+ struct inv_list data;
+
+ data.list_values = NULL;
+ data.replacement = NULL;
+ walk_tree (node, find_inv_trees, (void *)&data, NULL);
+
+ if (vec_safe_length (data.list_values))
+ {
+ node_list = push_stmt_list ();
+ for (ix = 0; vec_safe_iterate (data.list_values, ix, &t); ix++)
+ {
+ 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 = build2 (MODIFY_EXPR, TREE_TYPE (t), new_var, t);
+ add_stmt (new_node);
+ vec_safe_push (data.replacement, new_var);
+ }
+ walk_tree (node, replace_inv_trees, (void *)&data, NULL);
+ node_list = pop_stmt_list (node_list);
+ }
+ return node_list;
+}
+
+/* Given a CALL_EXPR to an array notation built-in function in
+ AN_BUILTIN_FN, replace the call with the appropriate loop and
+ computation. Return the computation in *NEW_VAR.
+
+ The return value in *NEW_VAR will always be a scalar. If the
+ built-in is __sec_reduce_mutating, *NEW_VAR is set to NULL_TREE. */
+
+static tree
+fix_builtin_array_notation_fn (tree an_builtin_fn, tree *new_var)
+{
+ tree new_var_type = NULL_TREE, func_parm, new_expr, 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_var_init = NULL_TREE;
+ 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, jj = 0;
+ int s_jj = 0;
+ tree **array_ops, *array_var, jj_tree, loop_init, array_op0;
+ tree **array_value, **array_stride, **array_length, **array_start;
+ tree *compare_expr, *expr_incr, *ind_init;
+ tree identity_value = NULL_TREE, call_fn = NULL_TREE, new_call_expr, body;
+ bool **count_down, **array_vector;
+ location_t location = UNKNOWN_LOCATION;
+ tree loop_with_init = alloc_stmt_list ();
+
+ enum built_in_function an_type =
+ is_cilkplus_reduce_builtin (CALL_EXPR_FN (an_builtin_fn));
+ if (an_type == BUILT_IN_NONE)
+ return NULL_TREE;
+
+ if (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE
+ || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING)
+ {
+ call_fn = CALL_EXPR_ARG (an_builtin_fn, 2);
+ while (TREE_CODE (call_fn) == CONVERT_EXPR
+ || TREE_CODE (call_fn) == NOP_EXPR)
+ call_fn = TREE_OPERAND (call_fn, 0);
+ call_fn = TREE_OPERAND (call_fn, 0);
+
+ identity_value = CALL_EXPR_ARG (an_builtin_fn, 0);
+ while (TREE_CODE (identity_value) == CONVERT_EXPR
+ || TREE_CODE (identity_value) == NOP_EXPR)
+ identity_value = TREE_OPERAND (identity_value, 0);
+ func_parm = CALL_EXPR_ARG (an_builtin_fn, 1);
+ }
+ else
+ func_parm = CALL_EXPR_ARG (an_builtin_fn, 0);
+
+ while (TREE_CODE (func_parm) == CONVERT_EXPR
+ || TREE_CODE (func_parm) == EXCESS_PRECISION_EXPR
+ || TREE_CODE (func_parm) == NOP_EXPR)
+ func_parm = TREE_OPERAND (func_parm, 0);
+
+ location = EXPR_LOCATION (an_builtin_fn);
+
+ if (!find_rank (location, an_builtin_fn, an_builtin_fn, true, &rank))
+ return error_mark_node;
+
+ if (rank == 0)
+ return an_builtin_fn;
+ else if (rank > 1
+ && (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
+ || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND))
+ {
+ error_at (location, "__sec_reduce_min_ind or __sec_reduce_max_ind cannot"
+ " have arrays with dimension greater than 1");
+ return error_mark_node;
+ }
+
+ extract_array_notation_exprs (func_parm, true, &array_list);
+ list_size = vec_safe_length (array_list);
+ switch (an_type)
+ {
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ADD:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MUL:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN:
+ new_var_type = TREE_TYPE ((*array_list)[0]);
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO:
+ new_var_type = integer_type_node;
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND:
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND:
+ new_var_type = integer_type_node;
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE:
+ if (call_fn && identity_value)
+ new_var_type = TREE_TYPE ((*array_list)[0]);
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING:
+ new_var_type = NULL_TREE;
+ break;
+ default:
+ gcc_unreachable ();
+ }
+
+ array_ops = XNEWVEC (tree *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_ops[ii] = XNEWVEC (tree, rank);
+
+ array_vector = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_vector[ii] = XNEWVEC (bool, rank);
+
+ array_value = XNEWVEC (tree *, list_size);
+ array_stride = XNEWVEC (tree *, list_size);
+ array_length = XNEWVEC (tree *, list_size);
+ array_start = XNEWVEC (tree *, list_size);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ array_value[ii] = XNEWVEC (tree, rank);
+ array_stride[ii] = XNEWVEC (tree, rank);
+ array_length[ii] = XNEWVEC (tree, rank);
+ array_start[ii] = XNEWVEC (tree, rank);
+ }
+
+ compare_expr = XNEWVEC (tree, rank);
+ expr_incr = XNEWVEC (tree, rank);
+ ind_init = XNEWVEC (tree, rank);
+
+ count_down = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ count_down[ii] = XNEWVEC (bool, rank);
+
+ array_var = XNEWVEC (tree, rank);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ jj = 0;
+ for (jj_tree = (*array_list)[ii];
+ jj_tree && TREE_CODE (jj_tree) == ARRAY_NOTATION_REF;
+ jj_tree = ARRAY_NOTATION_ARRAY (jj_tree))
+ {
+ array_ops[ii][jj] = jj_tree;
+ jj++;
+ }
+ }
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ if (TREE_CODE (array_node) == ARRAY_NOTATION_REF)
+ {
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (TREE_CODE (array_ops[ii][jj]) == ARRAY_NOTATION_REF)
+ {
+ array_value[ii][jj] =
+ ARRAY_NOTATION_ARRAY (array_ops[ii][jj]);
+ array_start[ii][jj] =
+ ARRAY_NOTATION_START (array_ops[ii][jj]);
+ array_length[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_LENGTH (array_ops[ii][jj]));
+ array_stride[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_STRIDE (array_ops[ii][jj]));
+ array_vector[ii][jj] = true;
+
+ if (!TREE_CONSTANT (array_length[ii][jj]))
+ count_down[ii][jj] = false;
+ else if (tree_int_cst_lt
+ (array_length[ii][jj],
+ build_int_cst (TREE_TYPE (array_length[ii][jj]),
+ 0)))
+ count_down[ii][jj] = true;
+ else
+ count_down[ii][jj] = false;
+ }
+ else
+ array_vector[ii][jj] = false;
+ }
+ }
+ }
+
+ loop_init = alloc_stmt_list ();
+
+ for (ii = 0; ii < rank; ii++)
+ {
+ array_var[ii] = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ ind_init[ii] =
+ build_modify_expr (location, array_var[ii],
+ TREE_TYPE (array_var[ii]), NOP_EXPR,
+ location,
+ build_int_cst (TREE_TYPE (array_var[ii]), 0),
+ TREE_TYPE (array_var[ii]));
+ }
+ for (ii = 0; ii < list_size; ii++)
+ {
+ if (array_vector[ii][0])
+ {
+ tree array_opr_node = array_value[ii][rank - 1];
+ for (s_jj = rank - 1; s_jj >= 0; s_jj--)
+ {
+ if (count_down[ii][s_jj])
+ {
+ /* Array[start_index - (induction_var * stride)] */
+ array_opr_node = build_array_ref
+ (location, array_opr_node,
+ build2 (MINUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ }
+ else
+ {
+ /* Array[start_index + (induction_var * stride)] */
+ array_opr_node = build_array_ref
+ (location, array_opr_node,
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ }
+ }
+ vec_safe_push (array_operand, array_opr_node);
+ }
+ else
+ /* This is just a dummy node to make sure the list sizes for both
+ array list and array operand list are the same. */
+ vec_safe_push (array_operand, integer_one_node);
+ }
+ replace_array_notations (&func_parm, true, array_list, array_operand);
+ for (ii = 0; ii < rank; ii++)
+ expr_incr[ii] =
+ build2 (MODIFY_EXPR, void_type_node, array_var[ii],
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[ii]), array_var[ii],
+ build_int_cst (TREE_TYPE (array_var[ii]), 1)));
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (rank && expr_incr[jj])
+ {
+ if (count_down[0][jj])
+ compare_expr[jj] =
+ build2 (LT_EXPR, boolean_type_node, array_var[jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[jj]),
+ array_length[0][jj],
+ build_int_cst (TREE_TYPE (array_var[jj]), -1)));
+ else
+ compare_expr[jj] = build2 (LT_EXPR, boolean_type_node,
+ array_var[jj], array_length[0][jj]);
+ }
+ }
+
+ if (an_type != BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING)
+ {
+ *new_var = build_decl (location, VAR_DECL, NULL_TREE, new_var_type);
+ gcc_assert (*new_var && *new_var != error_mark_node);
+ }
+ else
+ *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 = build_decl (location, VAR_DECL, NULL_TREE,
+ TREE_TYPE (func_parm));
+ array_op0 = (*array_operand)[0];
+ switch (an_type)
+ {
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ADD:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_zero_cst (new_var_type), new_var_type);
+ new_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), PLUS_EXPR,
+ location, func_parm, TREE_TYPE (func_parm));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MUL:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_one_cst (new_var_type), new_var_type);
+ new_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), MULT_EXPR,
+ location, func_parm, TREE_TYPE (func_parm));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_one_cst (new_var_type), new_var_type);
+ /* Initially you assume everything is zero, now if we find a case where
+ it is NOT true, then we set the result to false. Otherwise
+ we just keep the previous value. */
+ new_yes_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_zero_cst (TREE_TYPE (*new_var)),
+ TREE_TYPE (*new_var));
+ new_no_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_cond_expr = build2 (NE_EXPR, TREE_TYPE (func_parm), func_parm,
+ build_zero_cst (TREE_TYPE (func_parm)));
+ new_expr = build_conditional_expr
+ (location, new_cond_expr, false, new_yes_expr,
+ TREE_TYPE (new_yes_expr), new_no_expr, TREE_TYPE (new_no_expr));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_one_cst (new_var_type), new_var_type);
+ /* Initially you assume everything is non-zero, now if we find a case
+ where it is NOT true, then we set the result to false. Otherwise
+ we just keep the previous value. */
+ new_yes_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_zero_cst (TREE_TYPE (*new_var)),
+ TREE_TYPE (*new_var));
+ new_no_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_cond_expr = build2 (EQ_EXPR, TREE_TYPE (func_parm), func_parm,
+ build_zero_cst (TREE_TYPE (func_parm)));
+ new_expr = build_conditional_expr
+ (location, new_cond_expr, false, new_yes_expr,
+ TREE_TYPE (new_yes_expr), new_no_expr, TREE_TYPE (new_no_expr));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_zero_cst (new_var_type), new_var_type);
+ /* Initially we assume there are NO zeros in the list. When we find
+ a non-zero, we keep the previous value. If we find a zero, we
+ set the value to true. */
+ new_yes_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_one_cst (new_var_type), new_var_type);
+ new_no_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_cond_expr = build2 (EQ_EXPR, TREE_TYPE (func_parm), func_parm,
+ build_zero_cst (TREE_TYPE (func_parm)));
+ new_expr = build_conditional_expr
+ (location, new_cond_expr, false, new_yes_expr,
+ TREE_TYPE (new_yes_expr), new_no_expr, TREE_TYPE (new_no_expr));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_zero_cst (new_var_type), new_var_type);
+ /* Initially we assume there are NO non-zeros in the list. When we find
+ a zero, we keep the previous value. If we find a non-zero, we set
+ the value to true. */
+ new_yes_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_one_cst (new_var_type), new_var_type);
+ new_no_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_cond_expr = build2 (NE_EXPR, TREE_TYPE (func_parm), func_parm,
+ build_zero_cst (TREE_TYPE (func_parm)));
+ new_expr = build_conditional_expr
+ (location, new_cond_expr, false, new_yes_expr,
+ TREE_TYPE (new_yes_expr), new_no_expr, TREE_TYPE (new_no_expr));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX:
+ if (TYPE_MIN_VALUE (new_var_type))
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, TYPE_MIN_VALUE (new_var_type), new_var_type);
+ else
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, func_parm, new_var_type);
+ new_no_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_yes_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, func_parm, TREE_TYPE (*new_var));
+ new_expr = build_conditional_expr
+ (location,
+ build2 (LT_EXPR, TREE_TYPE (*new_var), *new_var, func_parm), false,
+ new_yes_expr, TREE_TYPE (*new_var), new_no_expr, TREE_TYPE (*new_var));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN:
+ if (TYPE_MAX_VALUE (new_var_type))
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, TYPE_MAX_VALUE (new_var_type), new_var_type);
+ else
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, func_parm, new_var_type);
+ new_no_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_yes_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, func_parm, TREE_TYPE (*new_var));
+ new_expr = build_conditional_expr
+ (location,
+ build2 (GT_EXPR, TREE_TYPE (*new_var), *new_var, func_parm), false,
+ new_yes_expr, TREE_TYPE (*new_var), new_no_expr, TREE_TYPE (*new_var));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_zero_cst (new_var_type), new_var_type);
+ new_exp_init = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR, location, func_parm, TREE_TYPE (func_parm));
+ new_no_ind = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_no_expr = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR,
+ location, array_ind_value, TREE_TYPE (array_ind_value));
+ if (list_size > 1)
+ {
+ new_yes_ind = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, array_var[0], TREE_TYPE (array_var[0]));
+ new_yes_expr = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR,
+ location, func_parm, TREE_TYPE ((*array_operand)[0]));
+ }
+ else
+ {
+ new_yes_ind = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, TREE_OPERAND (array_op0, 1),
+ TREE_TYPE (TREE_OPERAND (array_op0, 1)));
+ new_yes_expr = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR,
+ location, func_parm, TREE_OPERAND (array_op0, 1));
+ }
+ new_yes_list = alloc_stmt_list ();
+ append_to_statement_list (new_yes_ind, &new_yes_list);
+ append_to_statement_list (new_yes_expr, &new_yes_list);
+
+ new_no_list = alloc_stmt_list ();
+ append_to_statement_list (new_no_ind, &new_no_list);
+ append_to_statement_list (new_no_expr, &new_no_list);
+
+ new_expr = build_conditional_expr
+ (location,
+ build2 (LE_EXPR, TREE_TYPE (array_ind_value), array_ind_value,
+ func_parm),
+ false,
+ new_yes_list, TREE_TYPE (*new_var), new_no_list, TREE_TYPE (*new_var));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, build_zero_cst (new_var_type), new_var_type);
+ new_exp_init = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR, location, func_parm, TREE_TYPE (func_parm));
+ new_no_ind = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, *new_var, TREE_TYPE (*new_var));
+ new_no_expr = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR,
+ location, array_ind_value, TREE_TYPE (array_ind_value));
+ if (list_size > 1)
+ {
+ new_yes_ind = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, array_var[0], TREE_TYPE (array_var[0]));
+ new_yes_expr = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR,
+ location, func_parm, TREE_TYPE (array_op0));
+ }
+ else
+ {
+ new_yes_ind = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, TREE_OPERAND (array_op0, 1),
+ TREE_TYPE (TREE_OPERAND (array_op0, 1)));
+ new_yes_expr = build_modify_expr
+ (location, array_ind_value, TREE_TYPE (array_ind_value),
+ NOP_EXPR,
+ location, func_parm, TREE_OPERAND (array_op0, 1));
+ }
+ new_yes_list = alloc_stmt_list ();
+ append_to_statement_list (new_yes_ind, &new_yes_list);
+ append_to_statement_list (new_yes_expr, &new_yes_list);
+
+ new_no_list = alloc_stmt_list ();
+ append_to_statement_list (new_no_ind, &new_no_list);
+ append_to_statement_list (new_no_expr, &new_no_list);
+
+ new_expr = build_conditional_expr
+ (location,
+ build2 (GE_EXPR, TREE_TYPE (array_ind_value), array_ind_value,
+ func_parm),
+ false,
+ new_yes_list, TREE_TYPE (*new_var), new_no_list, TREE_TYPE (*new_var));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE:
+ new_var_init = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, identity_value, new_var_type);
+ new_call_expr = build_call_expr (call_fn, 2, *new_var, func_parm);
+ new_expr = build_modify_expr
+ (location, *new_var, TREE_TYPE (*new_var), NOP_EXPR,
+ location, new_call_expr, TREE_TYPE (*new_var));
+ break;
+ case BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING:
+ new_expr = build_call_expr (call_fn, 2, identity_value, func_parm);
+ break;
+ default:
+ gcc_unreachable ();
+ break;
+ }
+
+ for (ii = 0; ii < rank; ii++)
+ append_to_statement_list (ind_init [ii], &loop_init);
+
+ if (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
+ || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND)
+ append_to_statement_list (new_exp_init, &loop_init);
+ if (an_type != BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING)
+ append_to_statement_list (new_var_init, &loop_init);
+
+ append_to_statement_list_force (loop_init, &loop_with_init);
+ body = new_expr;
+ for (ii = 0; ii < rank; ii++)
+ {
+ tree new_loop = push_stmt_list ();
+ c_finish_loop (location, compare_expr[ii], expr_incr[ii], body, NULL_TREE,
+ NULL_TREE, true);
+ body = pop_stmt_list (new_loop);
+ }
+ append_to_statement_list_force (body, &loop_with_init);
+
+ XDELETEVEC (compare_expr);
+ XDELETEVEC (expr_incr);
+ XDELETEVEC (ind_init);
+ XDELETEVEC (array_var);
+ for (ii = 0; ii < list_size; ii++)
+ {
+ XDELETEVEC (count_down[ii]);
+ XDELETEVEC (array_value[ii]);
+ XDELETEVEC (array_stride[ii]);
+ XDELETEVEC (array_length[ii]);
+ XDELETEVEC (array_start[ii]);
+ XDELETEVEC (array_ops[ii]);
+ XDELETEVEC (array_vector[ii]);
+ }
+ XDELETEVEC (count_down);
+ XDELETEVEC (array_value);
+ XDELETEVEC (array_stride);
+ XDELETEVEC (array_length);
+ XDELETEVEC (array_start);
+ XDELETEVEC (array_ops);
+ XDELETEVEC (array_vector);
+
+ return loop_with_init;
+}
+
+/* Returns a loop with ARRAY_REF inside it with an appropriate modify expr.
+ The LHS and/or RHS will be array notation expressions that have a MODIFYCODE
+ Their locations are specified by LHS_LOC, RHS_LOC. The location of the
+ modify expression is location. The original type of LHS and RHS are passed
+ in LHS_ORIGTYPE and RHS_ORIGTYPE. */
+
+tree
+build_array_notation_expr (location_t location, tree lhs, tree lhs_origtype,
+ enum tree_code modifycode, location_t rhs_loc,
+ tree rhs, tree rhs_origtype)
+{
+ bool **lhs_vector = NULL, **rhs_vector = NULL, found_builtin_fn = false;
+ tree **lhs_array = NULL, **rhs_array = NULL;
+ tree array_expr_lhs = NULL_TREE, array_expr_rhs = NULL_TREE;
+ tree array_expr = NULL_TREE;
+ tree **lhs_value = NULL, **rhs_value = NULL;
+ tree **lhs_stride = NULL, **lhs_length = NULL, **lhs_start = NULL;
+ tree **rhs_stride = NULL, **rhs_length = NULL, **rhs_start = NULL;
+ tree an_init = NULL_TREE, *lhs_var = NULL, *rhs_var = NULL;
+ tree *cond_expr = NULL;
+ tree body, loop_with_init = alloc_stmt_list();
+ tree scalar_mods = NULL_TREE;
+ tree *lhs_expr_incr = NULL, *rhs_expr_incr = NULL;
+ tree *lhs_ind_init = NULL, *rhs_ind_init = NULL;
+ bool **lhs_count_down = NULL, **rhs_count_down = NULL;
+ tree *lhs_compare = NULL, *rhs_compare = NULL;
+ vec<tree, va_gc> *rhs_array_operand = NULL, *lhs_array_operand = NULL;
+ size_t lhs_rank = 0, rhs_rank = 0;
+ size_t ii = 0, jj = 0;
+ int s_jj = 0;
+ tree ii_tree = NULL_TREE, new_modify_expr;
+ vec<tree, va_gc> *lhs_list = NULL, *rhs_list = NULL;
+ tree new_var = NULL_TREE, builtin_loop = NULL_TREE;
+ tree begin_var, lngth_var, strde_var;
+ size_t rhs_list_size = 0, lhs_list_size = 0;
+
+ /* If either of this is true, an error message must have been send out
+ already. Not necessary to send out multiple error messages. */
+ if (lhs == error_mark_node || rhs == error_mark_node)
+ return error_mark_node;
+
+ if (!find_rank (location, rhs, rhs, false, &rhs_rank))
+ return error_mark_node;
+
+ extract_array_notation_exprs (rhs, false, &rhs_list);
+ rhs_list_size = vec_safe_length (rhs_list);
+ an_init = push_stmt_list ();
+ if (rhs_rank)
+ {
+ scalar_mods = replace_invariant_exprs (&rhs);
+ if (scalar_mods)
+ add_stmt (scalar_mods);
+ }
+ for (ii = 0; ii < rhs_list_size; ii++)
+ {
+ tree rhs_node = (*rhs_list)[ii];
+ if (TREE_CODE (rhs_node) == CALL_EXPR)
+ {
+ builtin_loop = fix_builtin_array_notation_fn (rhs_node, &new_var);
+ if (builtin_loop == error_mark_node)
+ {
+ pop_stmt_list (an_init);
+ return error_mark_node;
+ }
+ else if (builtin_loop)
+ {
+ add_stmt (builtin_loop);
+ found_builtin_fn = true;
+ if (new_var)
+ {
+ vec<tree, va_gc> *rhs_sub_list = NULL, *new_var_list = NULL;
+ vec_safe_push (rhs_sub_list, rhs_node);
+ vec_safe_push (new_var_list, new_var);
+ replace_array_notations (&rhs, false, rhs_sub_list,
+ new_var_list);
+ }
+ }
+ }
+ }
+
+ lhs_rank = 0;
+ rhs_rank = 0;
+ if (!find_rank (location, lhs, lhs, true, &lhs_rank))
+ {
+ pop_stmt_list (an_init);
+ return error_mark_node;
+ }
+
+ if (!find_rank (location, rhs, rhs, true, &rhs_rank))
+ {
+ pop_stmt_list (an_init);
+ return error_mark_node;
+ }
+
+ if (lhs_rank == 0 && rhs_rank == 0)
+ {
+ if (found_builtin_fn)
+ {
+ new_modify_expr = build_modify_expr (location, lhs, lhs_origtype,
+ modifycode, rhs_loc, rhs,
+ rhs_origtype);
+ add_stmt (new_modify_expr);
+ pop_stmt_list (an_init);
+ return an_init;
+ }
+ else
+ {
+ pop_stmt_list (an_init);
+ return NULL_TREE;
+ }
+ }
+ rhs_list_size = 0;
+ rhs_list = NULL;
+ extract_array_notation_exprs (rhs, true, &rhs_list);
+ extract_array_notation_exprs (lhs, true, &lhs_list);
+ rhs_list_size = vec_safe_length (rhs_list);
+ lhs_list_size = vec_safe_length (lhs_list);
+
+ if (lhs_rank == 0 && rhs_rank != 0 && TREE_CODE (rhs) != CALL_EXPR)
+ {
+ tree rhs_base = rhs;
+ if (TREE_CODE (rhs_base) == ARRAY_NOTATION_REF)
+ {
+ for (ii = 0; ii < (size_t) rhs_rank; ii++)
+ rhs_base = ARRAY_NOTATION_ARRAY (rhs);
+
+ error_at (location, "%qE cannot be scalar when %qE is not", lhs,
+ rhs_base);
+ return error_mark_node;
+ }
+ else
+ {
+ error_at (location, "%qE cannot be scalar when %qE is not", lhs,
+ rhs_base);
+ return error_mark_node;
+ }
+ }
+ if (lhs_rank != 0 && rhs_rank != 0 && lhs_rank != rhs_rank)
+ {
+ tree lhs_base = lhs;
+ tree rhs_base = rhs;
+
+ for (ii = 0; ii < lhs_rank; ii++)
+ lhs_base = ARRAY_NOTATION_ARRAY (lhs_base);
+
+ while (rhs_base && TREE_CODE (rhs_base) != ARRAY_NOTATION_REF)
+ rhs_base = TREE_OPERAND (rhs_base, 0);
+ for (ii = 0; ii < rhs_rank; ii++)
+ rhs_base = ARRAY_NOTATION_ARRAY (rhs_base);
+
+ error_at (location, "rank mismatch between %qE and %qE", lhs, rhs);
+ pop_stmt_list (an_init);
+ return error_mark_node;
+ }
+
+ /* Here we assign the array notation components to variable so that we can
+ satisfy the exec once rule. */
+ for (ii = 0; ii < lhs_list_size; ii++)
+ {
+ tree array_node = (*lhs_list)[ii];
+ tree array_begin = ARRAY_NOTATION_START (array_node);
+ tree array_lngth = ARRAY_NOTATION_LENGTH (array_node);
+ tree array_strde = ARRAY_NOTATION_STRIDE (array_node);
+
+ if (TREE_CODE (array_begin) != INTEGER_CST)
+ {
+ begin_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, begin_var,
+ TREE_TYPE (begin_var),
+ NOP_EXPR, location, array_begin,
+ TREE_TYPE (array_begin)));
+ ARRAY_NOTATION_START (array_node) = begin_var;
+ }
+
+ if (TREE_CODE (array_lngth) != INTEGER_CST)
+ {
+ lngth_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, lngth_var,
+ TREE_TYPE (lngth_var),
+ NOP_EXPR, location, array_lngth,
+ TREE_TYPE (array_lngth)));
+ ARRAY_NOTATION_LENGTH (array_node) = lngth_var;
+ }
+ if (TREE_CODE (array_strde) != INTEGER_CST)
+ {
+ strde_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+
+ add_stmt (build_modify_expr (location, strde_var,
+ TREE_TYPE (strde_var),
+ NOP_EXPR, location, array_strde,
+ TREE_TYPE (array_strde)));
+ ARRAY_NOTATION_STRIDE (array_node) = strde_var;
+ }
+ }
+ for (ii = 0; ii < rhs_list_size; ii++)
+ {
+ tree array_node = (*rhs_list)[ii];
+ if (array_node && TREE_CODE (array_node) == ARRAY_NOTATION_REF)
+ {
+ tree array_begin = ARRAY_NOTATION_START (array_node);
+ tree array_lngth = ARRAY_NOTATION_LENGTH (array_node);
+ tree array_strde = ARRAY_NOTATION_STRIDE (array_node);
+
+ if (TREE_CODE (array_begin) != INTEGER_CST)
+ {
+ begin_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, begin_var,
+ TREE_TYPE (begin_var),
+ NOP_EXPR, location, array_begin,
+ TREE_TYPE (array_begin)));
+ ARRAY_NOTATION_START (array_node) = begin_var;
+ }
+ if (TREE_CODE (array_lngth) != INTEGER_CST)
+ {
+ lngth_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, lngth_var,
+ TREE_TYPE (lngth_var),
+ NOP_EXPR, location, array_lngth,
+ TREE_TYPE (array_lngth)));
+ ARRAY_NOTATION_LENGTH (array_node) = lngth_var;
+ }
+ if (TREE_CODE (array_strde) != INTEGER_CST)
+ {
+ strde_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+
+ add_stmt (build_modify_expr (location, strde_var,
+ TREE_TYPE (strde_var),
+ NOP_EXPR, location, array_strde,
+ TREE_TYPE (array_strde)));
+ ARRAY_NOTATION_STRIDE (array_node) = strde_var;
+ }
+ }
+ }
+
+ lhs_vector = XNEWVEC (bool *, lhs_list_size);
+ for (ii = 0; ii < lhs_list_size; ii++)
+ lhs_vector[ii] = XNEWVEC (bool, lhs_rank);
+
+ rhs_vector = XNEWVEC (bool *, rhs_list_size);
+ for (ii = 0; ii < rhs_list_size; ii++)
+ rhs_vector[ii] = XNEWVEC (bool, rhs_rank);
+
+ lhs_array = XNEWVEC (tree *, lhs_list_size);
+ for (ii = 0; ii < lhs_list_size; ii++)
+ lhs_array[ii] = XNEWVEC (tree, lhs_rank);
+
+ rhs_array = XNEWVEC (tree *, rhs_list_size);
+ for (ii = 0; ii < rhs_list_size; ii++)
+ rhs_array[ii] = XNEWVEC (tree, rhs_rank);
+
+ lhs_value = XNEWVEC (tree *, lhs_list_size);
+ for (ii = 0; ii < lhs_list_size; ii++)
+ lhs_value[ii] = XNEWVEC (tree, lhs_rank);
+
+ rhs_value = XNEWVEC (tree *, rhs_list_size);
+ for (ii = 0; ii < rhs_list_size; ii++)
+ rhs_value[ii] = XNEWVEC (tree, rhs_rank);
+
+ lhs_stride = XNEWVEC (tree *, lhs_list_size);
+ for (ii = 0; ii < lhs_list_size; ii++)
+ lhs_stride[ii] = XNEWVEC (tree, lhs_rank);
+
+ rhs_stride = XNEWVEC (tree *, rhs_list_size);
+ for (ii = 0; ii < rhs_list_size; ii++)
+ rhs_stride[ii] = XNEWVEC (tree, rhs_rank);
+
+ lhs_length = XNEWVEC (tree *, lhs_list_size);
+ for (ii = 0; ii < lhs_list_size; ii++)
+ lhs_length[ii] = XNEWVEC (tree, lhs_rank);
+
+ rhs_length = XNEWVEC (tree *, rhs_list_size);
+ for (ii = 0; ii < rhs_list_size; ii++)
+ rhs_length[ii] = XNEWVEC (tree, rhs_rank);
+
+ lhs_start = XNEWVEC (tree *, lhs_list_size);
+ for (ii = 0; ii < lhs_list_size; ii++)
+ lhs_start[ii] = XNEWVEC (tree, lhs_rank);
+
+ rhs_start = XNEWVEC (tree *, rhs_list_size);
+ for (ii = 0; ii < rhs_list_size; ii++)
+ rhs_start[ii] = XNEWVEC (tree, rhs_rank);
+
+ lhs_var = XNEWVEC (tree, lhs_rank);
+ rhs_var = XNEWVEC (tree, rhs_rank);
+ cond_expr = XNEWVEC (tree, MAX (lhs_rank, rhs_rank));
+
+ lhs_expr_incr = XNEWVEC (tree, lhs_rank);
+ rhs_expr_incr =XNEWVEC (tree, rhs_rank);
+
+ lhs_ind_init = XNEWVEC (tree, lhs_rank);
+ rhs_ind_init = XNEWVEC (tree, rhs_rank);
+
+ lhs_count_down = XNEWVEC (bool *, lhs_list_size);
+ for (ii = 0; ii < lhs_list_size; ii++)
+ lhs_count_down[ii] = XNEWVEC (bool, lhs_rank);
+
+ rhs_count_down = XNEWVEC (bool *, rhs_list_size);
+ for (ii = 0; ii < rhs_list_size; ii++)
+ rhs_count_down[ii] = XNEWVEC (bool, rhs_rank);
+
+ lhs_compare = XNEWVEC (tree, lhs_rank);
+ rhs_compare = XNEWVEC (tree, rhs_rank);
+
+ if (lhs_rank)
+ {
+ for (ii = 0; ii < lhs_list_size; ii++)
+ {
+ jj = 0;
+ ii_tree = (*lhs_list)[ii];
+ while (ii_tree)
+ {
+ if (TREE_CODE (ii_tree) == ARRAY_NOTATION_REF)
+ {
+ lhs_array[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) == PARM_DECL)
+ break;
+ }
+ }
+ }
+ else
+ lhs_array[0][0] = NULL_TREE;
+
+ if (rhs_rank)
+ {
+ for (ii = 0; ii < rhs_list_size; ii++)
+ {
+ jj = 0;
+ ii_tree = (*rhs_list)[ii];
+ while (ii_tree)
+ {
+ if (TREE_CODE (ii_tree) == ARRAY_NOTATION_REF)
+ {
+ rhs_array[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) == PARM_DECL
+ || TREE_CODE (ii_tree) == CALL_EXPR)
+ break;
+ }
+ }
+ }
+
+ for (ii = 0; ii < lhs_list_size; ii++)
+ {
+ tree lhs_node = (*lhs_list)[ii];
+ if (TREE_CODE (lhs_node) == ARRAY_NOTATION_REF)
+ {
+ for (jj = 0; jj < lhs_rank; jj++)
+ {
+ if (TREE_CODE (lhs_array[ii][jj]) == ARRAY_NOTATION_REF)
+ {
+ lhs_value[ii][jj] = ARRAY_NOTATION_ARRAY (lhs_array[ii][jj]);
+ lhs_start[ii][jj] = ARRAY_NOTATION_START (lhs_array[ii][jj]);
+ lhs_length[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_LENGTH (lhs_array[ii][jj]));
+ lhs_stride[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_STRIDE (lhs_array[ii][jj]));
+ lhs_vector[ii][jj] = true;
+ /* IF the stride value is variable (i.e. not constant) then
+ assume that the length is positive. */
+ if (!TREE_CONSTANT (lhs_length[ii][jj]))
+ lhs_count_down[ii][jj] = false;
+ else if (tree_int_cst_lt
+ (lhs_length[ii][jj],
+ build_zero_cst (TREE_TYPE (lhs_length[ii][jj]))))
+ lhs_count_down[ii][jj] = true;
+ else
+ lhs_count_down[ii][jj] = false;
+ }
+ else
+ lhs_vector[ii][jj] = false;
+ }
+ }
+ }
+ for (ii = 0; ii < rhs_list_size; ii++)
+ {
+ if (TREE_CODE ((*rhs_list)[ii]) == ARRAY_NOTATION_REF)
+ {
+ for (jj = 0; jj < rhs_rank; jj++)
+ {
+ if (TREE_CODE (rhs_array[ii][jj]) == ARRAY_NOTATION_REF)
+ {
+ rhs_value[ii][jj] = ARRAY_NOTATION_ARRAY (rhs_array[ii][jj]);
+ rhs_start[ii][jj] = ARRAY_NOTATION_START (rhs_array[ii][jj]);
+ rhs_length[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_LENGTH (rhs_array[ii][jj]));
+ rhs_stride[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_STRIDE (rhs_array[ii][jj]));
+ rhs_vector[ii][jj] = true;
+ /* If the stride value is variable (i.e. not constant) then
+ assume that the length is positive. */
+ if (!TREE_CONSTANT (rhs_length[ii][jj]))
+ rhs_count_down[ii][jj] = false;
+ else if (tree_int_cst_lt
+ (rhs_length[ii][jj],
+ build_int_cst (TREE_TYPE (rhs_length[ii][jj]), 0)))
+ rhs_count_down[ii][jj] = true;
+ else
+ rhs_count_down[ii][jj] = false;
+ }
+ else
+ rhs_vector[ii][jj] = false;
+ }
+ }
+ else
+ for (jj = 0; jj < rhs_rank; jj++)
+ rhs_vector[ii][jj] = false;
+ }
+
+ if (length_mismatch_in_expr_p (EXPR_LOCATION (lhs), lhs_length,
+ lhs_list_size, lhs_rank)
+ || length_mismatch_in_expr_p (EXPR_LOCATION (rhs), rhs_length,
+ rhs_list_size, rhs_rank))
+ {
+ pop_stmt_list (an_init);
+ return error_mark_node;
+ }
+
+ if (lhs_list_size > 0 && rhs_list_size > 0 && lhs_rank > 0 && rhs_rank > 0
+ && TREE_CODE (lhs_length[0][0]) == INTEGER_CST
+ && TREE_CODE (rhs_length[0][0]) == INTEGER_CST)
+ {
+ HOST_WIDE_INT l_length = int_cst_value (lhs_length[0][0]);
+ HOST_WIDE_INT r_length = int_cst_value (rhs_length[0][0]);
+ /* Length can be negative or positive. As long as the magnitude is OK,
+ then the array notation is valid. */
+ if (abs (l_length) != abs (r_length))
+ {
+ 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_vector[0][ii])
+ {
+ lhs_var[ii] = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ lhs_ind_init[ii] = build_modify_expr
+ (location, lhs_var[ii], TREE_TYPE (lhs_var[ii]),
+ NOP_EXPR,
+ location, build_zero_cst (TREE_TYPE (lhs_var[ii])),
+ TREE_TYPE (lhs_var[ii]));
+ }
+ }
+
+ for (ii = 0; ii < rhs_rank; ii++)
+ {
+ /* When we have a polynomial, we assume that the indices are of type
+ integer. */
+ rhs_var[ii] = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ rhs_ind_init[ii] = build_modify_expr
+ (location, rhs_var[ii], TREE_TYPE (rhs_var[ii]),
+ NOP_EXPR,
+ location, build_int_cst (TREE_TYPE (rhs_var[ii]), 0),
+ TREE_TYPE (rhs_var[ii]));
+ }
+ if (lhs_rank)
+ {
+ for (ii = 0; ii < lhs_list_size; ii++)
+ {
+ if (lhs_vector[ii][0])
+ {
+ /* The last ARRAY_NOTATION element's ARRAY component should be
+ the array's base value. */
+ tree lhs_array_opr = lhs_value[ii][lhs_rank - 1];
+ for (s_jj = lhs_rank - 1; s_jj >= 0; s_jj--)
+ {
+ if (lhs_count_down[ii][s_jj])
+ /* Array[start_index + (induction_var * stride)]. */
+ lhs_array_opr = build_array_ref
+ (location, lhs_array_opr,
+ build2 (MINUS_EXPR, TREE_TYPE (lhs_var[s_jj]),
+ lhs_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (lhs_var[s_jj]),
+ lhs_var[s_jj],
+ lhs_stride[ii][s_jj])));
+ else
+ lhs_array_opr = build_array_ref
+ (location, lhs_array_opr,
+ build2 (PLUS_EXPR, TREE_TYPE (lhs_var[s_jj]),
+ lhs_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (lhs_var[s_jj]),
+ lhs_var[s_jj],
+ lhs_stride[ii][s_jj])));
+ }
+ vec_safe_push (lhs_array_operand, lhs_array_opr);
+ }
+ else
+ vec_safe_push (lhs_array_operand, integer_one_node);
+ }
+ replace_array_notations (&lhs, true, lhs_list, lhs_array_operand);
+ array_expr_lhs = lhs;
+ }
+
+ if (rhs_rank)
+ {
+ for (ii = 0; ii < rhs_list_size; ii++)
+ {
+ if (rhs_vector[ii][0])
+ {
+ tree rhs_array_opr = rhs_value[ii][rhs_rank - 1];
+ for (s_jj = rhs_rank - 1; s_jj >= 0; s_jj--)
+ {
+ if (rhs_count_down[ii][s_jj])
+ /* Array[start_index - (induction_var * stride)] */
+ rhs_array_opr = build_array_ref
+ (location, rhs_array_opr,
+ build2 (MINUS_EXPR, TREE_TYPE (rhs_var[s_jj]),
+ rhs_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (rhs_var[s_jj]),
+ rhs_var[s_jj],
+ rhs_stride[ii][s_jj])));
+ else
+ /* Array[start_index + (induction_var * stride)] */
+ rhs_array_opr = build_array_ref
+ (location, rhs_array_opr,
+ build2 (PLUS_EXPR, TREE_TYPE (rhs_var[s_jj]),
+ rhs_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (rhs_var[s_jj]),
+ rhs_var[s_jj],
+ rhs_stride[ii][s_jj])));
+ }
+ vec_safe_push (rhs_array_operand, rhs_array_opr);
+ }
+ else
+ /* This is just a dummy node to make sure the list sizes for both
+ array list and array operand list are the same. */
+ vec_safe_push (rhs_array_operand, integer_one_node);
+ }
+
+ for (ii = 0; ii < rhs_list_size; ii++)
+ {
+ tree rhs_node = (*rhs_list)[ii];
+ if (TREE_CODE (rhs_node) == CALL_EXPR)
+ {
+ int idx_value = 0;
+ tree func_name = CALL_EXPR_FN (rhs_node);
+ if (TREE_CODE (func_name) == ADDR_EXPR)
+ if (is_sec_implicit_index_fn (func_name))
+ {
+ idx_value =
+ extract_sec_implicit_index_arg (location, rhs_node);
+ if (idx_value == -1) /* This means we have an error. */
+ return error_mark_node;
+ else if (idx_value < (int) lhs_rank && idx_value >= 0)
+ vec_safe_push (rhs_array_operand, lhs_var[idx_value]);
+ else
+ {
+ size_t ee = 0;
+ tree lhs_base = (*lhs_list)[ii];
+ for (ee = 0; ee < lhs_rank; ee++)
+ lhs_base = ARRAY_NOTATION_ARRAY (lhs_base);
+ error_at (location, "__sec_implicit_index argument %d "
+ "must be less than rank of %qD", idx_value,
+ lhs_base);
+ return error_mark_node;
+ }
+ }
+ }
+ }
+ replace_array_notations (&rhs, true, rhs_list, rhs_array_operand);
+ array_expr_rhs = rhs;
+ }
+ else
+ {
+ for (ii = 0; ii < rhs_list_size; ii++)
+ {
+ tree rhs_node = (*rhs_list)[ii];
+ if (TREE_CODE (rhs_node) == CALL_EXPR)
+ {
+ int idx_value = 0;
+ tree func_name = CALL_EXPR_FN (rhs_node);
+ if (TREE_CODE (func_name) == ADDR_EXPR)
+ if (is_sec_implicit_index_fn (func_name))
+ {
+ idx_value =
+ extract_sec_implicit_index_arg (location, rhs_node);
+ if (idx_value == -1) /* This means we have an error. */
+ return error_mark_node;
+ else if (idx_value < (int) lhs_rank && idx_value >= 0)
+ vec_safe_push (rhs_array_operand, lhs_var[idx_value]);
+ else
+ {
+ size_t ee = 0;
+ tree lhs_base = (*lhs_list)[ii];
+ for (ee = 0; ee < lhs_rank; ee++)
+ lhs_base = ARRAY_NOTATION_ARRAY (lhs_base);
+ error_at (location, "__sec_implicit_index argument %d "
+ "must be less than rank of %qD", idx_value,
+ lhs_base);
+ return error_mark_node;
+ }
+ }
+ }
+ }
+ replace_array_notations (&rhs, true, rhs_list, rhs_array_operand);
+ array_expr_rhs = rhs;
+ rhs_expr_incr[0] = NULL_TREE;
+ }
+
+ for (ii = 0; ii < rhs_rank; ii++)
+ rhs_expr_incr[ii] = build2 (MODIFY_EXPR, void_type_node, rhs_var[ii],
+ build2
+ (PLUS_EXPR, TREE_TYPE (rhs_var[ii]),
+ rhs_var[ii],
+ build_one_cst (TREE_TYPE (rhs_var[ii]))));
+
+ for (ii = 0; ii < lhs_rank; ii++)
+ lhs_expr_incr[ii] = build2
+ (MODIFY_EXPR, void_type_node, lhs_var[ii],
+ build2 (PLUS_EXPR, TREE_TYPE (lhs_var[ii]), lhs_var[ii],
+ build_one_cst (TREE_TYPE (lhs_var[ii]))));
+
+ /* If array_expr_lhs is NULL, then we have function that returns void or
+ its return value is ignored. */
+ if (!array_expr_lhs)
+ array_expr_lhs = lhs;
+
+ array_expr = build_modify_expr (location, array_expr_lhs, lhs_origtype,
+ modifycode, rhs_loc, array_expr_rhs,
+ rhs_origtype);
+
+ for (jj = 0; jj < MAX (lhs_rank, rhs_rank); jj++)
+ {
+ if (rhs_rank && rhs_expr_incr[jj])
+ {
+ size_t iii = 0;
+ if (lhs_rank == 0)
+ lhs_compare[jj] = integer_one_node;
+ else if (lhs_count_down[0][jj])
+ lhs_compare[jj] = build2
+ (GT_EXPR, boolean_type_node, lhs_var[jj], lhs_length[0][jj]);
+ else
+ lhs_compare[jj] = build2
+ (LT_EXPR, boolean_type_node, lhs_var[jj], lhs_length[0][jj]);
+
+
+ /* The reason why we have this here is for the following case:
+ Array[:][:] = function_call(something) + Array2[:][:];
+
+ So, we will skip the first operand of RHS and then go to the
+ 2nd to find whether we should count up or down. */
+
+ for (iii = 0; iii < rhs_list_size; iii++)
+ if (rhs_vector[iii][jj])
+ break;
+
+ /* What we are doing here is this:
+ We always count up, so:
+ if (length is negative ==> which means we count down)
+ we multiply length by -1 and count up => ii < -LENGTH
+ else
+ we just count up, so we compare for ii < LENGTH
+ */
+ if (rhs_count_down[iii][jj])
+ /* We use iii for rhs_length because that is the correct countdown
+ we have to use. */
+ rhs_compare[jj] = build2
+ (LT_EXPR, boolean_type_node, rhs_var[jj],
+ build2 (MULT_EXPR, TREE_TYPE (rhs_var[jj]),
+ rhs_length[iii][jj],
+ build_int_cst (TREE_TYPE (rhs_var[jj]), -1)));
+ else
+ rhs_compare[jj] = build2 (LT_EXPR, boolean_type_node, rhs_var[jj],
+ rhs_length[iii][jj]);
+ if (lhs_compare[ii] != integer_one_node)
+ cond_expr[jj] = build2 (TRUTH_ANDIF_EXPR, void_type_node,
+ lhs_compare[jj], rhs_compare[jj]);
+ else
+ cond_expr[jj] = rhs_compare[jj];
+ }
+ else
+ {
+ if (lhs_count_down[0][jj])
+ cond_expr[jj] = build2
+ (GT_EXPR, boolean_type_node, lhs_var[jj], lhs_length[0][jj]);
+ else
+ cond_expr[jj] = build2
+ (LT_EXPR, boolean_type_node, lhs_var[jj], lhs_length[0][jj]);
+ }
+ }
+
+ an_init = pop_stmt_list (an_init);
+ append_to_statement_list_force (an_init, &loop_with_init);
+ body = array_expr;
+ for (ii = 0; ii < MAX (lhs_rank, rhs_rank); ii++)
+ {
+ tree incr_list = alloc_stmt_list ();
+ tree new_loop = push_stmt_list ();
+ if (lhs_rank)
+ add_stmt (lhs_ind_init[ii]);
+ if (rhs_rank)
+ add_stmt (rhs_ind_init[ii]);
+ if (lhs_rank)
+ append_to_statement_list_force (lhs_expr_incr[ii], &incr_list);
+ if (rhs_rank && rhs_expr_incr[ii])
+ append_to_statement_list_force (rhs_expr_incr[ii], &incr_list);
+ c_finish_loop (location, cond_expr[ii], incr_list, body, NULL_TREE,
+ NULL_TREE, true);
+ body = pop_stmt_list (new_loop);
+ }
+ append_to_statement_list_force (body, &loop_with_init);
+ return loop_with_init;
+}
+
+/* Helper function for fix_conditional_array_notations. Encloses the
+ conditional statement passed in STMT with a loop around it
+ and replaces the condition in STMT with a ARRAY_REF tree-node to the array.
+ The condition must have an ARRAY_NOTATION_REF tree. An expansion of array
+ notation in STMT is returned in a STATEMENT_LIST. */
+
+static tree
+fix_conditional_array_notations_1 (tree stmt)
+{
+ vec<tree, va_gc> *array_list = NULL, *array_operand = NULL;
+ size_t list_size = 0;
+ tree cond = NULL_TREE, builtin_loop = NULL_TREE, new_var = NULL_TREE;
+ size_t rank = 0, ii = 0, jj = 0;
+ int s_jj = 0;
+ tree **array_ops, *array_var, jj_tree, loop_init;
+ tree **array_value, **array_stride, **array_length, **array_start;
+ tree *compare_expr, *expr_incr, *ind_init;
+ bool **count_down, **array_vector;
+ tree begin_var, lngth_var, strde_var;
+ location_t location = EXPR_LOCATION (stmt);
+ tree body = NULL_TREE, loop_with_init = alloc_stmt_list ();
+ if (TREE_CODE (stmt) == COND_EXPR)
+ cond = COND_EXPR_COND (stmt);
+ else if (TREE_CODE (stmt) == SWITCH_EXPR)
+ cond = SWITCH_COND (stmt);
+ else
+ /* Otherwise dont even touch the statement. */
+ return stmt;
+
+ if (!find_rank (location, cond, cond, false, &rank))
+ return error_mark_node;
+
+ extract_array_notation_exprs (cond, false, &array_list);
+ loop_init = push_stmt_list ();
+ for (ii = 0; ii < vec_safe_length (array_list); ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ if (TREE_CODE (array_node) == CALL_EXPR)
+ {
+ builtin_loop = fix_builtin_array_notation_fn (array_node, &new_var);
+ if (builtin_loop == error_mark_node)
+ {
+ add_stmt (error_mark_node);
+ pop_stmt_list (loop_init);
+ return loop_init;
+ }
+ else if (builtin_loop)
+ {
+ vec <tree, va_gc>* sub_list = NULL, *new_var_list = NULL;
+ vec_safe_push (sub_list, array_node);
+ vec_safe_push (new_var_list, new_var);
+ add_stmt (builtin_loop);
+ replace_array_notations (&cond, false, sub_list, new_var_list);
+ }
+ }
+ }
+
+ if (!find_rank (location, cond, cond, true, &rank))
+ {
+ pop_stmt_list (loop_init);
+ return error_mark_node;
+ }
+ if (rank == 0)
+ {
+ add_stmt (stmt);
+ pop_stmt_list (loop_init);
+ return loop_init;
+ }
+ extract_array_notation_exprs (cond, true, &array_list);
+
+ if (vec_safe_length (array_list) == 0)
+ return stmt;
+
+ list_size = vec_safe_length (array_list);
+
+ array_ops = XNEWVEC (tree *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_ops[ii] = XNEWVEC (tree, rank);
+
+ array_vector = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_vector[ii] = XNEWVEC (bool, rank);
+
+ array_value = XNEWVEC (tree *, list_size);
+ array_stride = XNEWVEC (tree *, list_size);
+ array_length = XNEWVEC (tree *, list_size);
+ array_start = XNEWVEC (tree *, list_size);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ array_value[ii] = XNEWVEC (tree, rank);
+ array_stride[ii] = XNEWVEC (tree, rank);
+ array_length[ii] = XNEWVEC (tree, rank);
+ array_start[ii] = XNEWVEC (tree, rank);
+ }
+
+ compare_expr = XNEWVEC (tree, rank);
+ expr_incr = XNEWVEC (tree, rank);
+ ind_init = XNEWVEC (tree, rank);
+
+ count_down = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ count_down[ii] = XNEWVEC (bool, rank);
+
+ array_var = XNEWVEC (tree, rank);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ if (array_node && TREE_CODE (array_node) == ARRAY_NOTATION_REF)
+ {
+ tree array_begin = ARRAY_NOTATION_START (array_node);
+ tree array_lngth = ARRAY_NOTATION_LENGTH (array_node);
+ tree array_strde = ARRAY_NOTATION_STRIDE (array_node);
+
+ if (TREE_CODE (array_begin) != INTEGER_CST)
+ {
+ begin_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, begin_var,
+ TREE_TYPE (begin_var),
+ NOP_EXPR, location, array_begin,
+ TREE_TYPE (array_begin)));
+ ARRAY_NOTATION_START (array_node) = begin_var;
+ }
+ if (TREE_CODE (array_lngth) != INTEGER_CST)
+ {
+ lngth_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, lngth_var,
+ TREE_TYPE (lngth_var),
+ NOP_EXPR, location, array_lngth,
+ TREE_TYPE (array_lngth)));
+ ARRAY_NOTATION_LENGTH (array_node) = lngth_var;
+ }
+ if (TREE_CODE (array_strde) != INTEGER_CST)
+ {
+ strde_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, strde_var,
+ TREE_TYPE (strde_var),
+ NOP_EXPR, location, array_strde,
+ TREE_TYPE (array_strde)));
+ ARRAY_NOTATION_STRIDE (array_node) = strde_var;
+ }
+ }
+ }
+ for (ii = 0; ii < list_size; ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ jj = 0;
+ for (jj_tree = array_node;
+ jj_tree && TREE_CODE (jj_tree) == ARRAY_NOTATION_REF;
+ jj_tree = ARRAY_NOTATION_ARRAY (jj_tree))
+ {
+ array_ops[ii][jj] = jj_tree;
+ jj++;
+ }
+ }
+ for (ii = 0; ii < list_size; ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ if (TREE_CODE (array_node) == ARRAY_NOTATION_REF)
+ {
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (TREE_CODE (array_ops[ii][jj]) == ARRAY_NOTATION_REF)
+ {
+ array_value[ii][jj] =
+ ARRAY_NOTATION_ARRAY (array_ops[ii][jj]);
+ array_start[ii][jj] =
+ ARRAY_NOTATION_START (array_ops[ii][jj]);
+ array_length[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_LENGTH (array_ops[ii][jj]));
+ array_stride[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_STRIDE (array_ops[ii][jj]));
+ array_vector[ii][jj] = true;
+
+ if (!TREE_CONSTANT (array_length[ii][jj]))
+ count_down[ii][jj] = false;
+ else if (tree_int_cst_lt
+ (array_length[ii][jj],
+ build_int_cst (TREE_TYPE (array_length[ii][jj]),
+ 0)))
+ count_down[ii][jj] = true;
+ else
+ count_down[ii][jj] = false;
+ }
+ else
+ array_vector[ii][jj] = false;
+ }
+ }
+ }
+
+ for (ii = 0; ii < rank; ii++)
+ {
+ array_var[ii] = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ ind_init[ii] =
+ build_modify_expr (location, array_var[ii],
+ TREE_TYPE (array_var[ii]), NOP_EXPR,
+ location,
+ build_int_cst (TREE_TYPE (array_var[ii]), 0),
+ TREE_TYPE (array_var[ii]));
+ }
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ if (array_vector[ii][0])
+ {
+ tree array_opr = array_value[ii][rank - 1];
+ for (s_jj = rank - 1; s_jj >= 0; s_jj--)
+ {
+ if (count_down[ii][s_jj])
+ /* Array[start_index - (induction_var * stride)] */
+ array_opr = build_array_ref
+ (location, array_opr,
+ build2 (MINUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ else
+ /* Array[start_index + (induction_var * stride)] */
+ array_opr = build_array_ref
+ (location, array_opr,
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ }
+ vec_safe_push (array_operand, array_opr);
+ }
+ else
+ /* This is just a dummy node to make sure the list sizes for both
+ array list and array operand list are the same. */
+ vec_safe_push (array_operand, integer_one_node);
+ }
+ replace_array_notations (&stmt, true, array_list, array_operand);
+ for (ii = 0; ii < rank; ii++)
+ expr_incr[ii] = build2 (MODIFY_EXPR, void_type_node, array_var[ii],
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[ii]),
+ array_var[ii],
+ build_int_cst (TREE_TYPE (array_var[ii]),
+ 1)));
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (rank && expr_incr[jj])
+ {
+ if (count_down[0][jj])
+ compare_expr[jj] =
+ build2 (LT_EXPR, boolean_type_node, array_var[jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[jj]),
+ array_length[0][jj],
+ build_int_cst (TREE_TYPE (array_var[jj]), -1)));
+ else
+ compare_expr[jj] = build2 (LT_EXPR, boolean_type_node,
+ array_var[jj], array_length[0][jj]);
+ }
+ }
+
+ loop_init = pop_stmt_list (loop_init);
+ body = stmt;
+ append_to_statement_list_force (loop_init, &loop_with_init);
+
+ for (ii = 0; ii < rank; ii++)
+ {
+ tree new_loop = push_stmt_list ();
+ add_stmt (ind_init[ii]);
+ c_finish_loop (location, compare_expr[ii], expr_incr[ii], body, NULL_TREE,
+ NULL_TREE, true);
+ body = pop_stmt_list (new_loop);
+ }
+ append_to_statement_list_force (body, &loop_with_init);
+ XDELETEVEC (expr_incr);
+ XDELETEVEC (ind_init);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ XDELETEVEC (count_down[ii]);
+ XDELETEVEC (array_value[ii]);
+ XDELETEVEC (array_stride[ii]);
+ XDELETEVEC (array_length[ii]);
+ XDELETEVEC (array_start[ii]);
+ XDELETEVEC (array_ops[ii]);
+ XDELETEVEC (array_vector[ii]);
+ }
+
+ XDELETEVEC (count_down);
+ XDELETEVEC (array_value);
+ XDELETEVEC (array_stride);
+ XDELETEVEC (array_length);
+ XDELETEVEC (array_start);
+ XDELETEVEC (array_ops);
+ XDELETEVEC (array_vector);
+
+ return loop_with_init;
+}
+
+/* Top-level function to replace ARRAY_NOTATION_REF in a conditional statement
+ in STMT. An expansion of array notation in STMT is returned as a
+ STATEMENT_LIST. */
+
+tree
+fix_conditional_array_notations (tree stmt)
+{
+ if (TREE_CODE (stmt) == STATEMENT_LIST)
+ {
+ tree_stmt_iterator tsi;
+ for (tsi = tsi_start (stmt); !tsi_end_p (tsi); tsi_next (&tsi))
+ {
+ tree single_stmt = *tsi_stmt_ptr (tsi);
+ *tsi_stmt_ptr (tsi) =
+ fix_conditional_array_notations_1 (single_stmt);
+ }
+ return stmt;
+ }
+ else
+ return fix_conditional_array_notations_1 (stmt);
+}
+
+/* Create a struct c_expr that contains a loop with ARRAY_REF expr at location
+ LOCATION with the tree_code CODE and the array notation expr is
+ passed in ARG. Returns the fixed c_expr in ARG itself. */
+
+struct c_expr
+fix_array_notation_expr (location_t location, enum tree_code code,
+ struct c_expr arg)
+{
+
+ vec<tree, va_gc> *array_list = NULL, *array_operand = NULL;
+ size_t list_size = 0, rank = 0, ii = 0, jj = 0;
+ int s_jj = 0;
+ tree **array_ops, *array_var, jj_tree, loop_init;
+ tree **array_value, **array_stride, **array_length, **array_start;
+ tree *compare_expr, *expr_incr, *ind_init;
+ tree body, loop_with_init = alloc_stmt_list ();
+ bool **count_down, **array_vector;
+
+ if (!find_rank (location, arg.value, arg.value, false, &rank))
+ {
+ /* If this function returns a NULL, we convert the tree value in the
+ structure to error_mark_node and the parser should take care of the
+ rest. */
+ arg.value = error_mark_node;
+ return arg;
+ }
+
+ if (rank == 0)
+ return arg;
+
+ extract_array_notation_exprs (arg.value, true, &array_list);
+
+ if (vec_safe_length (array_list) == 0)
+ return arg;
+
+ list_size = vec_safe_length (array_list);
+
+ array_ops = XNEWVEC (tree *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_ops[ii] = XNEWVEC (tree, rank);
+
+ array_vector = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_vector[ii] = XNEWVEC (bool, rank);
+
+ array_value = XNEWVEC (tree *, list_size);
+ array_stride = XNEWVEC (tree *, list_size);
+ array_length = XNEWVEC (tree *, list_size);
+ array_start = XNEWVEC (tree *, list_size);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ array_value[ii] = XNEWVEC (tree, rank);
+ array_stride[ii] = XNEWVEC (tree, rank);
+ array_length[ii] = XNEWVEC (tree, rank);
+ array_start[ii] = XNEWVEC (tree, rank);
+ }
+
+ compare_expr = XNEWVEC (tree, rank);
+ expr_incr = XNEWVEC (tree, rank);
+ ind_init = XNEWVEC (tree, rank);
+
+ count_down = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ count_down[ii] = XNEWVEC (bool, rank);
+ array_var = XNEWVEC (tree, rank);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ jj = 0;
+ for (jj_tree = (*array_list)[ii];
+ jj_tree && TREE_CODE (jj_tree) == ARRAY_NOTATION_REF;
+ jj_tree = ARRAY_NOTATION_ARRAY (jj_tree))
+ {
+ array_ops[ii][jj] = jj_tree;
+ jj++;
+ }
+ }
+
+ loop_init = push_stmt_list ();
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ if (TREE_CODE (array_node) == ARRAY_NOTATION_REF)
+ {
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (TREE_CODE (array_ops[ii][jj]) == ARRAY_NOTATION_REF)
+ {
+ array_value[ii][jj] =
+ ARRAY_NOTATION_ARRAY (array_ops[ii][jj]);
+ array_start[ii][jj] =
+ ARRAY_NOTATION_START (array_ops[ii][jj]);
+ array_length[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_LENGTH (array_ops[ii][jj]));
+ array_stride[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_STRIDE (array_ops[ii][jj]));
+ array_vector[ii][jj] = true;
+
+ if (!TREE_CONSTANT (array_length[ii][jj]))
+ count_down[ii][jj] = false;
+ else if (tree_int_cst_lt
+ (array_length[ii][jj],
+ build_int_cst (TREE_TYPE (array_length[ii][jj]),
+ 0)))
+ count_down[ii][jj] = true;
+ else
+ count_down[ii][jj] = false;
+ }
+ else
+ array_vector[ii][jj] = false;
+ }
+ }
+ }
+
+ for (ii = 0; ii < rank; ii++)
+ {
+ array_var[ii] = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ ind_init[ii] =
+ build_modify_expr (location, array_var[ii],
+ TREE_TYPE (array_var[ii]), NOP_EXPR,
+ location,
+ build_int_cst (TREE_TYPE (array_var[ii]), 0),
+ TREE_TYPE (array_var[ii]));
+
+ }
+ for (ii = 0; ii < list_size; ii++)
+ {
+ if (array_vector[ii][0])
+ {
+ tree array_opr = array_value[ii][rank - 1];
+ for (s_jj = rank - 1; s_jj >= 0; s_jj--)
+ {
+ if (count_down[ii][s_jj])
+ /* Array[start_index - (induction_var * stride)] */
+ array_opr = build_array_ref
+ (location, array_opr,
+ build2 (MINUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ else
+ /* Array[start_index + (induction_var * stride)] */
+ array_opr = build_array_ref
+ (location, array_opr,
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ }
+ vec_safe_push (array_operand, array_opr);
+ }
+ else
+ /* This is just a dummy node to make sure the list sizes for both
+ array list and array operand list are the same. */
+ vec_safe_push (array_operand, integer_one_node);
+ }
+ replace_array_notations (&arg.value, true, array_list, array_operand);
+
+ for (ii = 0; ii < rank; ii++)
+ expr_incr[ii] =
+ build2 (MODIFY_EXPR, void_type_node, array_var[ii],
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[ii]), array_var[ii],
+ build_int_cst (TREE_TYPE (array_var[ii]), 1)));
+
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (rank && expr_incr[jj])
+ {
+ if (count_down[0][jj])
+ compare_expr[jj] =
+ build2 (LT_EXPR, boolean_type_node, array_var[jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[jj]),
+ array_length[0][jj],
+ build_int_cst (TREE_TYPE (array_var[jj]), -1)));
+ else
+ compare_expr[jj] = build2 (LT_EXPR, boolean_type_node,
+ array_var[jj], array_length[0][jj]);
+ }
+ }
+
+ if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
+ {
+ arg = default_function_array_read_conversion (location, arg);
+ arg.value = build_unary_op (location, code, arg.value, 0);
+ }
+ else if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
+ {
+ arg = default_function_array_read_conversion (location, arg);
+ arg = parser_build_unary_op (location, code, arg);
+ }
+
+ loop_init = pop_stmt_list (loop_init);
+ append_to_statement_list_force (loop_init, &loop_with_init);
+ body = arg.value;
+
+ for (ii = 0; ii < rank; ii++)
+ {
+ tree new_loop = push_stmt_list ();
+ add_stmt (ind_init[ii]);
+ c_finish_loop (location, compare_expr[ii], expr_incr[ii], body, NULL_TREE,
+ NULL_TREE, true);
+ body = pop_stmt_list (new_loop);
+ }
+ append_to_statement_list_force (body, &loop_with_init);
+ XDELETEVEC (expr_incr);
+ XDELETEVEC (ind_init);
+ XDELETEVEC (array_var);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ XDELETEVEC (count_down[ii]);
+ XDELETEVEC (array_value[ii]);
+ XDELETEVEC (array_stride[ii]);
+ XDELETEVEC (array_length[ii]);
+ XDELETEVEC (array_start[ii]);
+ XDELETEVEC (array_ops[ii]);
+ XDELETEVEC (array_vector[ii]);
+ }
+
+ XDELETEVEC (count_down);
+ XDELETEVEC (array_value);
+ XDELETEVEC (array_stride);
+ XDELETEVEC (array_length);
+ XDELETEVEC (array_start);
+ XDELETEVEC (array_ops);
+ XDELETEVEC (array_vector);
+
+ arg.value = loop_with_init;
+ return arg;
+}
+
+/* Returns true if EXPR or any of its subtrees contain ARRAY_NOTATION_EXPR
+ node. */
+
+bool
+contains_array_notation_expr (tree expr)
+{
+ vec<tree, va_gc> *array_list = NULL;
+
+ if (!expr)
+ return false;
+ if (TREE_CODE (expr) == FUNCTION_DECL)
+ if (is_cilkplus_reduce_builtin (expr))
+ return true;
+
+ extract_array_notation_exprs (expr, false, &array_list);
+ if (vec_safe_length (array_list) == 0)
+ return false;
+ else
+ return true;
+}
+
+/* Replaces array notations in a void function call arguments in ARG and returns
+ a STATEMENT_LIST. */
+
+static tree
+fix_array_notation_call_expr (tree arg)
+{
+ vec<tree, va_gc> *array_list = NULL, *array_operand = NULL;
+ tree new_var = NULL_TREE;
+ size_t list_size = 0, rank = 0, ii = 0, jj = 0;
+ int s_jj = 0;
+ tree **array_ops, *array_var, jj_tree, loop_init;
+ tree **array_value, **array_stride, **array_length, **array_start;
+ tree body, loop_with_init = alloc_stmt_list ();
+ tree *compare_expr, *expr_incr, *ind_init;
+ bool **count_down, **array_vector;
+ tree begin_var, lngth_var, strde_var;
+ location_t location = UNKNOWN_LOCATION;
+
+ if (TREE_CODE (arg) == CALL_EXPR
+ && is_cilkplus_reduce_builtin (CALL_EXPR_FN (arg)))
+ {
+ loop_init = fix_builtin_array_notation_fn (arg, &new_var);
+ /* We are ignoring the new var because either the user does not want to
+ capture it OR he is using sec_reduce_mutating function. */
+ return loop_init;
+ }
+
+ if (!find_rank (location, arg, arg, false, &rank))
+ return error_mark_node;
+
+ if (rank == 0)
+ return arg;
+
+ extract_array_notation_exprs (arg, true, &array_list);
+ if (vec_safe_length (array_list) == 0)
+ return arg;
+
+ list_size = vec_safe_length (array_list);
+ location = EXPR_LOCATION (arg);
+
+ array_ops = XNEWVEC (tree *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_ops[ii] = XNEWVEC (tree, rank);
+
+ array_vector = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ array_vector[ii] = (bool *) XNEWVEC (bool, rank);
+
+ array_value = XNEWVEC (tree *, list_size);
+ array_stride = XNEWVEC (tree *, list_size);
+ array_length = XNEWVEC (tree *, list_size);
+ array_start = XNEWVEC (tree *, list_size);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ array_value[ii] = XNEWVEC (tree, rank);
+ array_stride[ii] = XNEWVEC (tree, rank);
+ array_length[ii] = XNEWVEC (tree, rank);
+ array_start[ii] = XNEWVEC (tree, rank);
+ }
+
+ compare_expr = XNEWVEC (tree, rank);
+ expr_incr = XNEWVEC (tree, rank);
+ ind_init = XNEWVEC (tree, rank);
+
+ count_down = XNEWVEC (bool *, list_size);
+ for (ii = 0; ii < list_size; ii++)
+ count_down[ii] = XNEWVEC (bool, rank);
+
+ array_var = XNEWVEC (tree, rank);
+
+ loop_init = push_stmt_list ();
+ for (ii = 0; ii < list_size; ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ if (array_node && TREE_CODE (array_node) == ARRAY_NOTATION_REF)
+ {
+ tree array_begin = ARRAY_NOTATION_START (array_node);
+ tree array_lngth = ARRAY_NOTATION_LENGTH (array_node);
+ tree array_strde = ARRAY_NOTATION_STRIDE (array_node);
+
+ if (TREE_CODE (array_begin) != INTEGER_CST)
+ {
+ begin_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, begin_var,
+ TREE_TYPE (begin_var),
+ NOP_EXPR, location, array_begin,
+ TREE_TYPE (array_begin)));
+ ARRAY_NOTATION_START (array_node) = begin_var;
+ }
+ if (TREE_CODE (array_lngth) != INTEGER_CST)
+ {
+ lngth_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, lngth_var,
+ TREE_TYPE (lngth_var),
+ NOP_EXPR, location, array_lngth,
+ TREE_TYPE (array_lngth)));
+ ARRAY_NOTATION_LENGTH (array_node) = lngth_var;
+ }
+ if (TREE_CODE (array_strde) != INTEGER_CST)
+ {
+ strde_var = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ add_stmt (build_modify_expr (location, strde_var,
+ TREE_TYPE (strde_var),
+ NOP_EXPR, location, array_strde,
+ TREE_TYPE (array_strde)));
+ ARRAY_NOTATION_STRIDE (array_node) = strde_var;
+ }
+ }
+ }
+ for (ii = 0; ii < list_size; ii++)
+ {
+ jj = 0;
+ for (jj_tree = (*array_list)[ii];
+ jj_tree && TREE_CODE (jj_tree) == ARRAY_NOTATION_REF;
+ jj_tree = ARRAY_NOTATION_ARRAY (jj_tree))
+ {
+ array_ops[ii][jj] = jj_tree;
+ jj++;
+ }
+ }
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ tree array_node = (*array_list)[ii];
+ if (TREE_CODE (array_node) == ARRAY_NOTATION_REF)
+ {
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (TREE_CODE (array_ops[ii][jj]) == ARRAY_NOTATION_REF)
+ {
+ array_value[ii][jj] =
+ ARRAY_NOTATION_ARRAY (array_ops[ii][jj]);
+ array_start[ii][jj] =
+ ARRAY_NOTATION_START (array_ops[ii][jj]);
+ array_length[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_LENGTH (array_ops[ii][jj]));
+ array_stride[ii][jj] =
+ fold_build1 (CONVERT_EXPR, integer_type_node,
+ ARRAY_NOTATION_STRIDE (array_ops[ii][jj]));
+ array_vector[ii][jj] = true;
+
+ if (!TREE_CONSTANT (array_length[ii][jj]))
+ count_down[ii][jj] = false;
+ else if (tree_int_cst_lt
+ (array_length[ii][jj],
+ build_int_cst (TREE_TYPE (array_length[ii][jj]),
+ 0)))
+ count_down[ii][jj] = true;
+ else
+ count_down[ii][jj] = false;
+ }
+ else
+ array_vector[ii][jj] = false;
+ }
+ }
+ }
+
+ if (length_mismatch_in_expr_p (location, array_length, list_size, rank))
+ {
+ pop_stmt_list (loop_init);
+ return error_mark_node;
+ }
+
+ for (ii = 0; ii < rank; ii++)
+ {
+ array_var[ii] = build_decl (location, VAR_DECL, NULL_TREE,
+ integer_type_node);
+ ind_init[ii] =
+ build_modify_expr (location, array_var[ii],
+ TREE_TYPE (array_var[ii]), NOP_EXPR,
+ location,
+ build_int_cst (TREE_TYPE (array_var[ii]), 0),
+ TREE_TYPE (array_var[ii]));
+
+ }
+ for (ii = 0; ii < list_size; ii++)
+ {
+ if (array_vector[ii][0])
+ {
+ tree array_opr_node = array_value[ii][rank - 1];
+ for (s_jj = rank - 1; s_jj >= 0; s_jj--)
+ {
+ if (count_down[ii][s_jj])
+ /* Array[start_index - (induction_var * stride)] */
+ array_opr_node = build_array_ref
+ (location, array_opr_node,
+ build2 (MINUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ else
+ /* Array[start_index + (induction_var * stride)] */
+ array_opr_node = build_array_ref
+ (location, array_opr_node,
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_start[ii][s_jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[s_jj]),
+ array_var[s_jj], array_stride[ii][s_jj])));
+ }
+ vec_safe_push (array_operand, array_opr_node);
+ }
+ else
+ /* This is just a dummy node to make sure the list sizes for both
+ array list and array operand list are the same. */
+ vec_safe_push (array_operand, integer_one_node);
+ }
+ replace_array_notations (&arg, true, array_list, array_operand);
+ for (ii = 0; ii < rank; ii++)
+ expr_incr[ii] =
+ build2 (MODIFY_EXPR, void_type_node, array_var[ii],
+ build2 (PLUS_EXPR, TREE_TYPE (array_var[ii]), array_var[ii],
+ build_int_cst (TREE_TYPE (array_var[ii]), 1)));
+
+ for (jj = 0; jj < rank; jj++)
+ {
+ if (rank && expr_incr[jj])
+ {
+ if (count_down[0][jj])
+ compare_expr[jj] =
+ build2 (LT_EXPR, boolean_type_node, array_var[jj],
+ build2 (MULT_EXPR, TREE_TYPE (array_var[jj]),
+ array_length[0][jj],
+ build_int_cst (TREE_TYPE (array_var[jj]), -1)));
+ else
+ compare_expr[jj] = build2 (LT_EXPR, boolean_type_node,
+ array_var[jj], array_length[0][jj]);
+ }
+ }
+
+ loop_init = pop_stmt_list (loop_init);
+ append_to_statement_list_force (loop_init, &loop_with_init);
+ body = arg;
+ for (ii = 0; ii < rank; ii++)
+ {
+ tree new_loop = push_stmt_list ();
+ add_stmt (ind_init[ii]);
+ c_finish_loop (location, compare_expr[ii], expr_incr[ii], body, NULL_TREE,
+ NULL_TREE, true);
+ body = pop_stmt_list (new_loop);
+ }
+ append_to_statement_list_force (body, &loop_with_init);
+ XDELETEVEC (compare_expr);
+ XDELETEVEC (expr_incr);
+ XDELETEVEC (ind_init);
+ XDELETEVEC (array_var);
+
+ for (ii = 0; ii < list_size; ii++)
+ {
+ XDELETEVEC (count_down[ii]);
+ XDELETEVEC (array_value[ii]);
+ XDELETEVEC (array_stride[ii]);
+ XDELETEVEC (array_length[ii]);
+ XDELETEVEC (array_start[ii]);
+ XDELETEVEC (array_ops[ii]);
+ XDELETEVEC (array_vector[ii]);
+ }
+
+ XDELETEVEC (count_down);
+ XDELETEVEC (array_value);
+ XDELETEVEC (array_stride);
+ XDELETEVEC (array_length);
+ XDELETEVEC (array_start);
+ XDELETEVEC (array_ops);
+ XDELETEVEC (array_vector);
+
+ return loop_with_init;
+}
+
+/* Expands the built-in functions in a return. EXPR is a RETURN_EXPR with
+ a built-in reduction function. This function returns the expansion code for
+ the built-in function. */
+
+static tree
+fix_return_expr (tree expr)
+{
+ tree new_mod_list, new_var, new_mod, retval_expr, retval_type;
+ location_t loc = EXPR_LOCATION (expr);
+
+ new_mod_list = alloc_stmt_list ();
+ retval_expr = TREE_OPERAND (expr, 0);
+ retval_type = TREE_TYPE (TREE_OPERAND (retval_expr, 1));
+ new_var = build_decl (loc, VAR_DECL, NULL_TREE, TREE_TYPE (retval_expr));
+ new_mod = build_array_notation_expr (loc, new_var, TREE_TYPE (new_var),
+ NOP_EXPR, loc,
+ TREE_OPERAND (retval_expr, 1),
+ retval_type);
+ 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);
+ return new_mod_list;
+}
+
+/* Walks through tree node T and find all the call-statements that do not return
+ anything and fix up any array notations they may carry. The return value
+ is the same type as T but with all array notations replaced with appropriate
+ STATEMENT_LISTS. */
+
+tree
+expand_array_notation_exprs (tree t)
+{
+ if (!contains_array_notation_expr (t))
+ return t;
+
+ switch (TREE_CODE (t))
+ {
+ case BIND_EXPR:
+ t = expand_array_notation_exprs (BIND_EXPR_BODY (t));
+ return t;
+ case COND_EXPR:
+ t = fix_conditional_array_notations (t);
+
+ /* After the expansion if they are still a COND_EXPR, we go into its
+ subtrees. */
+ if (TREE_CODE (t) == COND_EXPR)
+ {
+ if (COND_EXPR_THEN (t))
+ COND_EXPR_THEN (t) =
+ expand_array_notation_exprs (COND_EXPR_THEN (t));
+ if (COND_EXPR_ELSE (t))
+ COND_EXPR_ELSE (t) =
+ expand_array_notation_exprs (COND_EXPR_ELSE (t));
+ }
+ else
+ t = expand_array_notation_exprs (t);
+ return t;
+ case STATEMENT_LIST:
+ {
+ tree_stmt_iterator ii_tsi;
+ for (ii_tsi = tsi_start (t); !tsi_end_p (ii_tsi); tsi_next (&ii_tsi))
+ *tsi_stmt_ptr (ii_tsi) =
+ expand_array_notation_exprs (*tsi_stmt_ptr (ii_tsi));
+ }
+ return t;
+ case CALL_EXPR:
+ t = fix_array_notation_call_expr (t);
+ return t;
+ case RETURN_EXPR:
+ if (contains_array_notation_expr (t))
+ t = fix_return_expr (t);
+ default:
+ return t;
+ }
+ return t;
+}
+
+/* This handles expression of the form "a[i:j:k]" or "a[:]" or "a[i:j]," which
+ denotes an array notation expression. If a is a variable or a member, then
+ we generate a ARRAY_NOTATION_REF front-end tree and return it.
+ This tree is broken down to ARRAY_REF toward the end of parsing.
+ ARRAY_NOTATION_REF tree holds the START_INDEX, LENGTH, STRIDE and the TYPE
+ of ARRAY_REF. Restrictions on START_INDEX, LENGTH and STRIDE is same as that
+ of the 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)
+{
+ tree array_ntn_tree = NULL_TREE;
+ size_t stride_rank = 0, length_rank = 0, start_rank = 0;
+
+ if (!INTEGRAL_TYPE_P (TREE_TYPE (start_index)))
+ {
+ error_at (loc,
+ "start-index of array notation triplet is not an integer");
+ return error_mark_node;
+ }
+ if (!INTEGRAL_TYPE_P (TREE_TYPE (length)))
+ {
+ error_at (loc, "length of array notation triplet is not an integer");
+ return error_mark_node;
+ }
+
+ /* The stride is an optional field. */
+ if (stride && !INTEGRAL_TYPE_P (TREE_TYPE (stride)))
+ {
+ error_at (loc, "stride of array notation triplet is not an integer");
+ return error_mark_node;
+ }
+ if (!stride)
+ {
+ if (TREE_CONSTANT (start_index) && TREE_CONSTANT (length)
+ && 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 (!find_rank (loc, start_index, start_index, false, &start_rank))
+ return error_mark_node;
+ if (!find_rank (loc, length, length, false, &length_rank))
+ return error_mark_node;
+ if (!find_rank (loc, stride, stride, false, &stride_rank))
+ return error_mark_node;
+
+ if (start_rank != 0)
+ {
+ error_at (loc, "rank of an array notation triplet's start-index is not "
+ "zero");
+ return error_mark_node;
+ }
+ if (length_rank != 0)
+ {
+ error_at (loc, "rank of an array notation triplet's length is not zero");
+ return error_mark_node;
+ }
+ if (stride_rank != 0)
+ {
+ error_at (loc, "rank of array notation triplet's stride is not zero");
+ return error_mark_node;
+ }
+ array_ntn_tree = build4 (ARRAY_NOTATION_REF, NULL_TREE, NULL_TREE, NULL_TREE,
+ NULL_TREE, NULL_TREE);
+ ARRAY_NOTATION_ARRAY (array_ntn_tree) = array;
+ ARRAY_NOTATION_START (array_ntn_tree) = start_index;
+ ARRAY_NOTATION_LENGTH (array_ntn_tree) = length;
+ ARRAY_NOTATION_STRIDE (array_ntn_tree) = stride;
+ TREE_TYPE (array_ntn_tree) = type;
+
+ return array_ntn_tree;
+}
+
+/* This function will check if OP is a CALL_EXPR that is a built-in array
+ notation function. If so, then we will return its type to be the type of
+ the array notation inside. */
+
+tree
+find_correct_array_notation_type (tree op)
+{
+ tree fn_arg, return_type = NULL_TREE;
+
+ if (op)
+ {
+ return_type = TREE_TYPE (op); /* This is the default case. */
+ if (TREE_CODE (op) == CALL_EXPR)
+ if (is_cilkplus_reduce_builtin (CALL_EXPR_FN (op)))
+ {
+ fn_arg = CALL_EXPR_ARG (op, 0);
+ if (fn_arg)
+ return_type = TREE_TYPE (fn_arg);
+ }
+ }
+ return return_type;
+}
projects / platform / upstream / gcc.git / commitdiff