diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 5af380adfb3..c797f1ddbe5 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,17 @@ +2013-05-28 Balaji V. Iyer + + * doc/extend.texi (C Extensions): Added documentation about Cilk Plus + array notation built-in reduction functions. + * doc/passes.texi (Passes): Added documentation about changes done + for Cilk Plus. + * doc/invoke.texi (C Dialect Options): Added documentation about + the -fcilkplus flag. + * Makefile.in (C_COMMON_OBJS): Added c-family/array-notation-common.o. + (BUILTINS_DEF): Depend on cilkplus.def. + * builtins.def: Include cilkplus.def. Define DEF_CILKPLUS_BUILTIN. + * builtin-types.def: Define BT_FN_INT_PTR_PTR_PTR. + * cilkplus.def: New file. + 2013-05-28 Joern Rennecke PR rtl-optimization/57439 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 1a965c18836..e95dd63c7db 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -869,7 +869,7 @@ RTL_ERROR_H = rtl-error.h $(RTL_H) $(DIAGNOSTIC_CORE_H) READ_MD_H = $(OBSTACK_H) $(HASHTAB_H) read-md.h PARAMS_H = params.h params.def BUILTINS_DEF = builtins.def sync-builtins.def omp-builtins.def \ - gtm-builtins.def sanitizer.def + gtm-builtins.def sanitizer.def cilkplus.def INTERNAL_FN_DEF = internal-fn.def INTERNAL_FN_H = internal-fn.h $(INTERNAL_FN_DEF) TREE_H = coretypes.h tree.h all-tree.def tree.def c-family/c-common.def \ @@ -1149,7 +1149,8 @@ C_COMMON_OBJS = c-family/c-common.o c-family/c-cppbuiltin.o c-family/c-dump.o \ c-family/c-format.o c-family/c-gimplify.o c-family/c-lex.o \ c-family/c-omp.o c-family/c-opts.o c-family/c-pch.o \ c-family/c-ppoutput.o c-family/c-pragma.o c-family/c-pretty-print.o \ - c-family/c-semantics.o c-family/c-ada-spec.o tree-mudflap.o + c-family/c-semantics.o c-family/c-ada-spec.o tree-mudflap.o \ + c-family/array-notation-common.o # Language-independent object files. # We put the insn-*.o files first so that a parallel make will build @@ -2014,6 +2015,9 @@ c-family/c-ada-spec.o : c-family/c-ada-spec.c c-family/c-ada-spec.h \ $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(CPP_ID_DATA_H) $(TM_H) \ coretypes.h tree-iterator.h $(DUMPFILE_H) +c-family/array-notation-common.o : c-family/array-notation-common.c $(TREE_H) \ + $(SYSTEM_H) $(TREE_H) coretypes.h tree-iterator.h $(DIAGNOSTIC_CORE_H) + c-family/stub-objc.o : c-family/stub-objc.c $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TREE_H) $(C_COMMON_H) c-family/c-objc.h diff --git a/gcc/builtin-types.def b/gcc/builtin-types.def index 3ef2d1bbf4a..2634eccabab 100644 --- a/gcc/builtin-types.def +++ b/gcc/builtin-types.def @@ -368,6 +368,8 @@ DEF_FUNCTION_TYPE_3 (BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG, BT_INT, BT_CONST_STRING, BT_CONST_STRING, BT_VALIST_ARG) DEF_FUNCTION_TYPE_3 (BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG, BT_INT, BT_FILEPTR, BT_CONST_STRING, BT_VALIST_ARG) +DEF_FUNCTION_TYPE_3 (BT_FN_INT_PTR_PTR_PTR, + BT_INT, BT_PTR, BT_PTR, BT_PTR) DEF_FUNCTION_TYPE_3 (BT_FN_STRING_CONST_STRING_CONST_STRING_INT, BT_STRING, BT_CONST_STRING, BT_CONST_STRING, BT_INT) DEF_FUNCTION_TYPE_3 (BT_FN_FLOAT_FLOAT_FLOAT_FLOAT, diff --git a/gcc/builtins.def b/gcc/builtins.def index 276f89c26e2..91879a64dc0 100644 --- a/gcc/builtins.def +++ b/gcc/builtins.def @@ -157,6 +157,11 @@ along with GCC; see the file COPYING3. If not see true, true, true, ATTRS, true, \ (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 an attribute list for math functions that are normally "impure" because some of them may write into global memory for `errno'. If !flag_errno_math they are instead "const". */ @@ -837,3 +842,5 @@ DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST) /* Sanitizer builtins. */ #include "sanitizer.def" +/* Cilk Plus builtins. */ +#include "cilkplus.def" diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 840a10e973f..d434a2f8ad6 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,24 @@ +2013-05-28 Balaji V. Iyer + + * c-common.c (c_define_builtins): When cilkplus is enabled, the + function array_notation_init_builtins is called. + (c_common_init_ts): Added ARRAY_NOTATION_REF as typed. + * c-common.def (ARRAY_NOTATION_REF): New tree. + * c-common.h (build_array_notation_expr): New function declaration. + (build_array_notation_ref): Likewise. + (extract_sec_implicit_index_arg): New extern declaration. + (is_sec_implicit_index_fn): Likewise. + (ARRAY_NOTATION_CHECK): New define. + (ARRAY_NOTATION_ARRAY): Likewise. + (ARRAY_NOTATION_START): Likewise. + (ARRAY_NOTATION_LENGTH): Likewise. + (ARRAY_NOTATION_STRIDE): Likewise. + * c-pretty-print.c (pp_c_postifix_expression): Added a new case for + ARRAY_NOTATION_REF. + (pp_c_expression): Likewise. + * c.opt (flag_enable_cilkplus): New flag. + * array-notation-common.c: New file. + 2013-05-14 Jakub Jelinek PR c++/57274 diff --git a/gcc/c-family/array-notation-common.c b/gcc/c-family/array-notation-common.c new file mode 100644 index 00000000000..1d288464eee --- /dev/null +++ b/gcc/c-family/array-notation-common.c @@ -0,0 +1,76 @@ +/* This file is part of the Intel(R) Cilk(TM) Plus support + This file contains the builtin functions for Array + notations. + Copyright (C) 2013 Free Software Foundation, Inc. + Contributed by Balaji V. Iyer , + 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 +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tree.h" +#include "langhooks.h" +#include "tree-iterator.h" +#include "diagnostic-core.h" + + +/* Returns true if the function call in FNDECL is __sec_implicit_index. */ + +bool +is_sec_implicit_index_fn (tree fndecl) +{ + if (TREE_CODE (fndecl) == ADDR_EXPR) + fndecl = TREE_OPERAND (fndecl, 0); + + return + (TREE_CODE (fndecl) == FUNCTION_DECL + && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL + && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CILKPLUS_SEC_IMPLICIT_INDEX); +} + +/* Returns the first and only argument for FN, which should be a + sec_implicit_index function. FN's location in the source file is as + indicated by LOCATION. The argument to FN must be a constant integer + expression, otherwise returns -1. */ + +HOST_WIDE_INT +extract_sec_implicit_index_arg (location_t location, tree fn) +{ + tree fn_arg; + HOST_WIDE_INT return_int = 0; + + if (TREE_CODE (fn) == CALL_EXPR) + { + fn_arg = CALL_EXPR_ARG (fn, 0); + if (TREE_CODE (fn_arg) == INTEGER_CST) + return_int = int_cst_value (fn_arg); + else + { + /* If the location is unknown, and if fn has a location, then use that + information so that the user has a better idea where the error + could be. */ + if (location == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (fn)) + location = EXPR_LOCATION (fn); + error_at (location, "__sec_implicit_index parameter must be an " + "integer constant expression"); + return -1; + } + } + return return_int; +} diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index 7f5d3165b8b..dec887fb4c0 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -11424,6 +11424,7 @@ c_common_init_ts (void) { MARK_TS_TYPED (C_MAYBE_CONST_EXPR); MARK_TS_TYPED (EXCESS_PRECISION_EXPR); + MARK_TS_TYPED (ARRAY_NOTATION_REF); } /* Build a user-defined numeric literal out of an integer constant type VALUE diff --git a/gcc/c-family/c-common.def b/gcc/c-family/c-common.def index 13113afe587..fac50e23777 100644 --- a/gcc/c-family/c-common.def +++ b/gcc/c-family/c-common.def @@ -55,6 +55,13 @@ DEFTREECODE (USERDEF_LITERAL, "userdef_literal", tcc_exceptional, 3) or for the purpose of -Wsizeof-pointer-memaccess warning. */ DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", tcc_expression, 1) +/* Array Notation expression. + Operand 0 is the array. + Operand 1 is the starting array index. + Operand 2 contains the number of elements you need to access. + Operand 3 is the stride. */ +DEFTREECODE (ARRAY_NOTATION_REF, "array_notation_ref", tcc_reference, 4) + /* Local variables: mode:c diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 4014651b876..d89982174bb 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -538,6 +538,10 @@ extern tree pushdecl_top_level (tree); extern tree pushdecl (tree); extern tree build_modify_expr (location_t, tree, tree, enum tree_code, location_t, tree, tree); +extern tree build_array_notation_expr (location_t, tree, tree, enum tree_code, + location_t, tree, tree); +extern tree build_array_notation_ref (location_t, tree, tree, tree, tree, tree); +extern bool find_rank (location_t, tree, tree, bool, size_t *); extern tree build_indirect_ref (location_t, tree, ref_operator); extern int field_decl_cmp (const void *, const void *); @@ -1133,4 +1137,26 @@ enum stv_conv { extern enum stv_conv scalar_to_vector (location_t loc, enum tree_code code, tree op0, tree op1, bool); +/* These #defines allow users to access different operands of the + array notation tree. */ + +#define ARRAY_NOTATION_CHECK(NODE) TREE_CHECK (NODE, ARRAY_NOTATION_REF) +#define ARRAY_NOTATION_ARRAY(NODE) \ + TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 0) +#define ARRAY_NOTATION_START(NODE) \ + TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 1) +#define ARRAY_NOTATION_LENGTH(NODE) \ + TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 2) +#define ARRAY_NOTATION_STRIDE(NODE) \ + TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 3) + +extern int extract_sec_implicit_index_arg (location_t, tree); +extern bool is_sec_implicit_index_fn (tree); +extern void array_notation_init_builtins (void); +extern struct c_expr fix_array_notation_expr (location_t, enum tree_code, + struct c_expr); +extern bool contains_array_notation_expr (tree); +extern tree expand_array_notation_exprs (tree); +extern tree fix_conditional_array_notations (tree); +extern tree find_correct_array_notation_type (tree); #endif /* ! GCC_C_COMMON_H */ diff --git a/gcc/c-family/c-pretty-print.c b/gcc/c-family/c-pretty-print.c index 13dd613d84e..b8af90c053c 100644 --- a/gcc/c-family/c-pretty-print.c +++ b/gcc/c-family/c-pretty-print.c @@ -1476,6 +1476,17 @@ pp_c_postfix_expression (c_pretty_printer *pp, tree e) pp_c_right_bracket (pp); break; + case ARRAY_NOTATION_REF: + pp_postfix_expression (pp, ARRAY_NOTATION_ARRAY (e)); + pp_c_left_bracket (pp); + pp_expression (pp, ARRAY_NOTATION_START (e)); + pp_colon (pp); + pp_expression (pp, ARRAY_NOTATION_LENGTH (e)); + pp_colon (pp); + pp_expression (pp, ARRAY_NOTATION_STRIDE (e)); + pp_c_right_bracket (pp); + break; + case CALL_EXPR: { call_expr_arg_iterator iter; @@ -2150,6 +2161,7 @@ pp_c_expression (c_pretty_printer *pp, tree e) case POSTINCREMENT_EXPR: case POSTDECREMENT_EXPR: case ARRAY_REF: + case ARRAY_NOTATION_REF: case CALL_EXPR: case COMPONENT_REF: case BIT_FIELD_REF: diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt index 124c13986a8..857813474c9 100644 --- a/gcc/c-family/c.opt +++ b/gcc/c-family/c.opt @@ -843,6 +843,10 @@ fcanonical-system-headers C ObjC C++ ObjC++ Where shorter, use canonicalized paths to systems headers. +fcilkplus +C ObjC C++ ObjC++ LTO Report Var(flag_enable_cilkplus) Init(0) +Enable Cilk Plus + fcheck-new C++ ObjC++ Var(flag_check_new) Check the return value of new diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index e0fef1e164f..d6d9856cf3b 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,45 @@ +2013-05-28 Balaji V. Iyer + + * c-typeck.c (build_array_ref): Added a check to see if array's + index is greater than one. If true, then emit an error. + (build_function_call_vec): Exclude error reporting and checking + for builtin array-notation functions. + (convert_arguments): Likewise. + (c_finish_return): Added a check for array notations as a return + expression. If true, then emit an error. + (c_finish_loop): Added a check for array notations in a loop + condition. If true then emit an error. + (lvalue_p): Added a ARRAY_NOTATION_REF case. + (build_binary_op): Added a check for array notation expr inside + op1 and op0. If present, we call another function to find correct + type. + * Make-lang.in (C_AND_OBJC_OBJS): Added c-array-notation.o. + * c-parser.c (c_parser_compound_statement): Check if array + notation code is used in tree, if so, then transform them into + appropriate C code. + (c_parser_expr_no_commas): Check if array notation is used in LHS + or RHS, if so, then build array notation expression instead of + regular modify. + (c_parser_postfix_expression_after_primary): Added a check for + colon(s) after square braces, if so then handle it like an array + notation. Also, break up array notations in unary op if found. + (c_parser_direct_declarator_inner): Added a check for array + notation. + (c_parser_compound_statement): Added a check for array notation in + a stmt. If one is present, then expand array notation expr. + (c_parser_if_statement): Likewise. + (c_parser_switch_statement): Added a check for array notations in + a switch statement's condition. If true, then output an error. + (c_parser_while_statement): Similarly, but for a while. + (c_parser_do_statement): Similarly, but for a do-while. + (c_parser_for_statement): Similarly, but for a for-loop. + (c_parser_unary_expression): Check if array notation is used in a + pre-increment or pre-decrement expression. If true, then expand + them. + (c_parser_array_notation): New function. + * c-array-notation.c: New file. + * c-tree.h (is_cilkplus_reduce_builtin): Protoize. + 2013-05-23 Mike Stump * c-typeck.c (convert_for_assignment): Handle references to memory diff --git a/gcc/c/Make-lang.in b/gcc/c/Make-lang.in index 47aa4cbef6f..1161742c274 100644 --- a/gcc/c/Make-lang.in +++ b/gcc/c/Make-lang.in @@ -56,7 +56,7 @@ c/gccspec.o: c/gccspec.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(GCC_H) \ # Language-specific object files for C and Objective C. C_AND_OBJC_OBJS = attribs.o c/c-errors.o c/c-decl.o c/c-typeck.o \ c/c-convert.o c/c-aux-info.o c/c-objc-common.o c/c-parser.o \ - $(C_COMMON_OBJS) $(C_TARGET_OBJS) + c/c-array-notation.o $(C_COMMON_OBJS) $(C_TARGET_OBJS) # Language-specific object files for C. C_OBJS = c/c-lang.o c-family/stub-objc.o $(C_AND_OBJC_OBJS) @@ -192,3 +192,8 @@ c/c-typeck.o : c/c-typeck.c c/c-lang.h $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_ langhooks.h tree-iterator.h $(BITMAP_H) $(GIMPLE_H) \ c-family/c-objc.h c-family/c-common.h +c/c-array-notation.o: c/c-array-notation.c c/c-lang.h $(CONFIG_H) \ + $(SYSTEM_H) coretypes.h $(TREE_H) $(C_TREE_H) $(TARGET_H) \ + intl.h output.h $(EXPR_H) langhooks.h tree-iterator.h $(BITMAP_H) \ + $(GIMPLE_H) c-family/c-objc.h + diff --git a/gcc/c/c-array-notation.c b/gcc/c/c-array-notation.c new file mode 100644 index 00000000000..c70345cfa98 --- /dev/null +++ b/gcc/c/c-array-notation.c @@ -0,0 +1,2875 @@ +/* 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 , + 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 + . */ + +/* 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] + + + 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] + ; + 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 *, + vec *); +static void extract_array_notation_exprs (tree, bool, vec **); + +/* 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 *list_values; + vec *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 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 **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[] contains + an array_notation expression, then ARRAY_OPERAND[] contains its + expansion. If *ORIG matches LIST[] then *ORIG is set to + ARRAY_OPERAND[]. 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 *list, + vec *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 *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 *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 *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 *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 *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 * 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 *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 *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 *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; +} diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c index f60f1414eb4..b89d8c1ff17 100644 --- a/gcc/c/c-parser.c +++ b/gcc/c/c-parser.c @@ -1216,6 +1216,8 @@ static void c_parser_objc_at_dynamic_declaration (c_parser *); static bool c_parser_objc_diagnose_bad_element_prefix (c_parser *, struct c_declspecs *); +static tree c_parser_array_notation (location_t, c_parser *, tree, tree); + /* Parse a translation unit (C90 6.7, C99 6.9). translation-unit: @@ -3067,6 +3069,15 @@ c_parser_direct_declarator_inner (c_parser *parser, bool id_present, dimen = NULL_TREE; star_seen = false; } + else if (flag_enable_cilkplus + && c_parser_next_token_is (parser, CPP_COLON)) + { + dimen = error_mark_node; + star_seen = false; + error_at (c_parser_peek_token (parser)->location, + "array notations cannot be used in declaration"); + c_parser_consume_token (parser); + } else if (c_parser_next_token_is (parser, CPP_MULT)) { if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE) @@ -3089,6 +3100,14 @@ c_parser_direct_declarator_inner (c_parser *parser, bool id_present, } if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) c_parser_consume_token (parser); + else if (flag_enable_cilkplus + && c_parser_next_token_is (parser, CPP_COLON)) + { + error_at (c_parser_peek_token (parser)->location, + "array notations cannot be used in declaration"); + c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); + return NULL; + } else { c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, @@ -4071,6 +4090,10 @@ c_parser_compound_statement (c_parser *parser) } stmt = c_begin_compound_stmt (true); c_parser_compound_statement_nostart (parser); + + /* If the compound stmt contains array notations, then we expand them. */ + if (flag_enable_cilkplus && contains_array_notation_expr (stmt)) + stmt = expand_array_notation_exprs (stmt); return c_end_compound_stmt (brace_loc, stmt, true); } @@ -4714,6 +4737,7 @@ c_parser_if_statement (c_parser *parser) bool first_if = false; tree first_body, second_body; bool in_if_block; + tree if_stmt; gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF)); c_parser_consume_token (parser); @@ -4732,7 +4756,12 @@ c_parser_if_statement (c_parser *parser) else second_body = NULL_TREE; c_finish_if_stmt (loc, cond, first_body, second_body, first_if); - add_stmt (c_end_compound_stmt (loc, block, flag_isoc99)); + if_stmt = c_end_compound_stmt (loc, block, flag_isoc99); + + /* If the if statement contains array notations, then we expand them. */ + if (flag_enable_cilkplus && contains_array_notation_expr (if_stmt)) + if_stmt = fix_conditional_array_notations (if_stmt); + add_stmt (if_stmt); } /* Parse a switch statement (C90 6.6.4, C99 6.8.4). @@ -4754,6 +4783,13 @@ c_parser_switch_statement (c_parser *parser) { switch_cond_loc = c_parser_peek_token (parser)->location; expr = c_parser_expression (parser).value; + if (flag_enable_cilkplus && contains_array_notation_expr (expr)) + { + error_at (switch_cond_loc, + "array notations cannot be used as a condition for switch " + "statement"); + expr = error_mark_node; + } c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); } else @@ -4793,6 +4829,12 @@ c_parser_while_statement (c_parser *parser) block = c_begin_compound_stmt (flag_isoc99); loc = c_parser_peek_token (parser)->location; cond = c_parser_paren_condition (parser); + if (flag_enable_cilkplus && contains_array_notation_expr (cond)) + { + error_at (loc, "array notations cannot be used as a condition for while " + "statement"); + cond = error_mark_node; + } save_break = c_break_label; c_break_label = NULL_TREE; save_cont = c_cont_label; @@ -4834,6 +4876,13 @@ c_parser_do_statement (c_parser *parser) new_cont = c_cont_label; c_cont_label = save_cont; cond = c_parser_paren_condition (parser); + if (flag_enable_cilkplus && contains_array_notation_expr (cond)) + { + error_at (loc, "array notations cannot be used as a condition for a " + "do-while statement"); + cond = error_mark_node; + } + if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) c_parser_skip_to_end_of_block_or_statement (parser); c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false); @@ -5009,7 +5058,14 @@ c_parser_for_statement (c_parser *parser) else { cond = c_parser_condition (parser); - c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); + if (flag_enable_cilkplus && contains_array_notation_expr (cond)) + { + error_at (loc, "array notations cannot be used in a " + "condition for a for-loop"); + cond = error_mark_node; + } + c_parser_skip_until_found (parser, CPP_SEMICOLON, + "expected %<;%>"); } } /* Parse the increment expression (the third expression in a @@ -5388,9 +5444,21 @@ c_parser_expr_no_commas (c_parser *parser, struct c_expr *after) exp_location = c_parser_peek_token (parser)->location; rhs = c_parser_expr_no_commas (parser, NULL); rhs = default_function_array_read_conversion (exp_location, rhs); - ret.value = build_modify_expr (op_location, lhs.value, lhs.original_type, - code, exp_location, rhs.value, - rhs.original_type); + + /* The line below is where the statement has the form: + A = B, where A and B contain array notation exprs. So this is where + we handle those. */ + if (flag_enable_cilkplus + && (contains_array_notation_expr (lhs.value) + || contains_array_notation_expr (rhs.value))) + ret.value = build_array_notation_expr (op_location, lhs.value, + lhs.original_type, code, + exp_location, rhs.value, + rhs.original_type); + else + ret.value = build_modify_expr (op_location, lhs.value, lhs.original_type, + code, exp_location, rhs.value, + rhs.original_type); if (code == NOP_EXPR) ret.original_code = MODIFY_EXPR; else @@ -5870,14 +5938,28 @@ c_parser_unary_expression (c_parser *parser) c_parser_consume_token (parser); exp_loc = c_parser_peek_token (parser)->location; op = c_parser_cast_expression (parser, NULL); - op = default_function_array_read_conversion (exp_loc, op); - return parser_build_unary_op (op_loc, PREINCREMENT_EXPR, op); + + /* If there is array notations in op, we expand them. */ + if (flag_enable_cilkplus && TREE_CODE (op.value) == ARRAY_NOTATION_REF) + return fix_array_notation_expr (exp_loc, PREINCREMENT_EXPR, op); + else + { + op = default_function_array_read_conversion (exp_loc, op); + return parser_build_unary_op (op_loc, PREINCREMENT_EXPR, op); + } case CPP_MINUS_MINUS: c_parser_consume_token (parser); exp_loc = c_parser_peek_token (parser)->location; op = c_parser_cast_expression (parser, NULL); - op = default_function_array_read_conversion (exp_loc, op); - return parser_build_unary_op (op_loc, PREDECREMENT_EXPR, op); + + /* If there is array notations in op, we expand them. */ + if (flag_enable_cilkplus && TREE_CODE (op.value) == ARRAY_NOTATION_REF) + return fix_array_notation_expr (exp_loc, PREDECREMENT_EXPR, op); + else + { + op = default_function_array_read_conversion (exp_loc, op); + return parser_build_unary_op (op_loc, PREDECREMENT_EXPR, op); + } case CPP_AND: c_parser_consume_token (parser); op = c_parser_cast_expression (parser, NULL); @@ -6880,10 +6962,36 @@ c_parser_postfix_expression_after_primary (c_parser *parser, case CPP_OPEN_SQUARE: /* Array reference. */ c_parser_consume_token (parser); - idx = c_parser_expression (parser).value; - c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, - "expected %<]%>"); - expr.value = build_array_ref (op_loc, expr.value, idx); + if (flag_enable_cilkplus + && c_parser_peek_token (parser)->type == CPP_COLON) + /* If we are here, then we have something like this: + Array [ : ] + */ + expr.value = c_parser_array_notation (expr_loc, parser, NULL_TREE, + expr.value); + else + { + idx = c_parser_expression (parser).value; + /* Here we have 3 options: + 1. Array [EXPR] -- Normal Array call. + 2. Array [EXPR : EXPR] -- Array notation without stride. + 3. Array [EXPR : EXPR : EXPR] -- Array notation with stride. + + For 1, we just handle it just like a normal array expression. + For 2 and 3 we handle it like we handle array notations. The + idx value we have above becomes the initial/start index. + */ + if (flag_enable_cilkplus + && c_parser_peek_token (parser)->type == CPP_COLON) + expr.value = c_parser_array_notation (expr_loc, parser, idx, + expr.value); + else + { + c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, + "expected %<]%>"); + expr.value = build_array_ref (op_loc, expr.value, idx); + } + } expr.original_code = ERROR_MARK; expr.original_type = NULL; break; @@ -6991,18 +7099,32 @@ c_parser_postfix_expression_after_primary (c_parser *parser, case CPP_PLUS_PLUS: /* Postincrement. */ c_parser_consume_token (parser); - expr = default_function_array_read_conversion (expr_loc, expr); - expr.value = build_unary_op (op_loc, - POSTINCREMENT_EXPR, expr.value, 0); + /* If the expressions have array notations, we expand them. */ + if (flag_enable_cilkplus + && TREE_CODE (expr.value) == ARRAY_NOTATION_REF) + expr = fix_array_notation_expr (expr_loc, POSTINCREMENT_EXPR, expr); + else + { + expr = default_function_array_read_conversion (expr_loc, expr); + expr.value = build_unary_op (op_loc, + POSTINCREMENT_EXPR, expr.value, 0); + } expr.original_code = ERROR_MARK; expr.original_type = NULL; break; case CPP_MINUS_MINUS: /* Postdecrement. */ c_parser_consume_token (parser); - expr = default_function_array_read_conversion (expr_loc, expr); - expr.value = build_unary_op (op_loc, - POSTDECREMENT_EXPR, expr.value, 0); + /* If the expressions have array notations, we expand them. */ + if (flag_enable_cilkplus + && TREE_CODE (expr.value) == ARRAY_NOTATION_REF) + expr = fix_array_notation_expr (expr_loc, POSTDECREMENT_EXPR, expr); + else + { + expr = default_function_array_read_conversion (expr_loc, expr); + expr.value = build_unary_op (op_loc, + POSTDECREMENT_EXPR, expr.value, 0); + } expr.original_code = ERROR_MARK; expr.original_type = NULL; break; @@ -10888,4 +11010,171 @@ c_parse_file (void) the_parser = NULL; } +/* This function parses Cilk Plus array notation. The starting index is + passed in INITIAL_INDEX and the array name is passes in ARRAY_VALUE. The + return value of this function is a tree_node called VALUE_TREE of type + ARRAY_NOTATION_REF. */ + +static tree +c_parser_array_notation (location_t loc, c_parser *parser, tree initial_index, + tree array_value) +{ + c_token *token = NULL; + tree start_index = NULL_TREE, end_index = NULL_TREE, stride = NULL_TREE; + tree value_tree = NULL_TREE, type = NULL_TREE, array_type = NULL_TREE; + tree array_type_domain = NULL_TREE; + + if (array_value == error_mark_node) + { + /* No need to continue. If either of these 2 were true, then an error + must be emitted already. Thus, no need to emit them twice. */ + c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); + return error_mark_node; + } + + array_type = TREE_TYPE (array_value); + gcc_assert (array_type); + type = TREE_TYPE (array_type); + token = c_parser_peek_token (parser); + + if (token->type == CPP_EOF) + { + c_parser_error (parser, "expected %<:%> or numeral"); + return value_tree; + } + else if (token->type == CPP_COLON) + { + if (!initial_index) + { + /* If we are here, then we have a case like this A[:]. */ + c_parser_consume_token (parser); + if (TREE_CODE (array_type) == POINTER_TYPE) + { + error_at (loc, "start-index and length fields necessary for " + "using array notations in pointers"); + c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); + return error_mark_node; + } + if (TREE_CODE (array_type) == FUNCTION_TYPE) + { + error_at (loc, "array notations cannot be used with function " + "type"); + 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) + { + error_at (loc, "start-index and length fields necessary for " + "using array notations in dimensionless arrays"); + c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); + return error_mark_node; + } + + start_index = TYPE_MINVAL (array_type_domain); + start_index = fold_build1 (CONVERT_EXPR, ptrdiff_type_node, + start_index); + if (!TYPE_MAXVAL (array_type_domain) + || !TREE_CONSTANT (TYPE_MAXVAL (array_type_domain))) + { + error_at (loc, "start-index and length fields necessary for " + "using array notations in variable-length arrays"); + c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); + return error_mark_node; + } + end_index = TYPE_MAXVAL (array_type_domain); + end_index = fold_build2 (PLUS_EXPR, TREE_TYPE (end_index), + end_index, integer_one_node); + end_index = fold_build1 (CONVERT_EXPR, ptrdiff_type_node, end_index); + stride = build_int_cst (integer_type_node, 1); + stride = fold_build1 (CONVERT_EXPR, ptrdiff_type_node, stride); + } + else if (initial_index != error_mark_node) + { + /* If we are here, then there should be 2 possibilities: + 1. Array [EXPR : EXPR] + 2. Array [EXPR : EXPR : EXPR] + */ + start_index = initial_index; + + if (TREE_CODE (array_type) == FUNCTION_TYPE) + { + error_at (loc, "array notations cannot be used with function " + "type"); + 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) + { + c_parser_skip_to_end_of_block_or_statement (parser); + return error_mark_node; + } + if (c_parser_peek_token (parser)->type == CPP_COLON) + { + c_parser_consume_token (parser); + stride = c_parser_expression (parser).value; + if (!stride || stride == error_mark_node) + { + c_parser_skip_to_end_of_block_or_statement (parser); + return error_mark_node; + } + } + } + else + c_parser_error (parser, "expected array notation expression"); + } + else + c_parser_error (parser, "expected array notation expression"); + + c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>"); + + value_tree = build_array_notation_ref (loc, array_value, start_index, + end_index, stride, type); + if (value_tree != error_mark_node) + SET_EXPR_LOCATION (value_tree, loc); + return value_tree; +} + #include "gt-c-c-parser.h" diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h index d1a871daa68..c8f673710e6 100644 --- a/gcc/c/c-tree.h +++ b/gcc/c/c-tree.h @@ -668,4 +668,7 @@ extern void c_write_global_declarations (void); extern void pedwarn_c90 (location_t, int opt, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4); extern void pedwarn_c99 (location_t, int opt, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4); +/* In c-array-notation.c */ +enum built_in_function is_cilkplus_reduce_builtin (tree); + #endif /* ! GCC_C_TREE_H */ diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c index 79386da59ad..749c8e2b8e9 100644 --- a/gcc/c/c-typeck.c +++ b/gcc/c/c-typeck.c @@ -2304,6 +2304,17 @@ build_array_ref (location_t loc, tree array, tree index) || TREE_TYPE (index) == error_mark_node) return error_mark_node; + if (flag_enable_cilkplus && contains_array_notation_expr (index)) + { + size_t rank = 0; + if (!find_rank (loc, index, index, true, &rank)) + return error_mark_node; + if (rank > 1) + { + error_at (loc, "rank of the array's index is greater than 1"); + return error_mark_node; + } + } if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE /* Allow vector[index] but not index[vector]. */ @@ -2722,6 +2733,10 @@ build_function_call_vec (location_t loc, tree function, often rewritten and don't match the original parameter list. */ if (name && !strncmp (IDENTIFIER_POINTER (name), "__atomic_", 9)) origtypes = NULL; + + if (flag_enable_cilkplus + && is_cilkplus_reduce_builtin (function)) + origtypes = NULL; } if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) function = function_to_pointer_conversion (loc, function); @@ -2944,6 +2959,17 @@ convert_arguments (tree typelist, vec *values, bool npc; tree parmval; + // FIXME: I assume this code is here to handle the overloaded + // behavior of the __sec_reduce* builtins, and avoid giving + // argument mismatch warnings/errors. We should probably handle + // this with the resolve_overloaded_builtin infrastructure. + /* If the function call is a builtin function call, then we do not + worry about it since we break them up into its equivalent later and + we do the appropriate checks there. */ + if (flag_enable_cilkplus + && is_cilkplus_reduce_builtin (fundecl)) + continue; + if (type == void_type_node) { if (selector) @@ -3181,10 +3207,16 @@ convert_arguments (tree typelist, vec *values, if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) { - error_at (input_location, - "too few arguments to function %qE", function); - inform_declaration (fundecl); - return -1; + /* If array notation is used and Cilk Plus is enabled, then we do not + worry about this error now. We will handle them in a later place. */ + if (!flag_enable_cilkplus + || !is_cilkplus_reduce_builtin (fundecl)) + { + error_at (input_location, + "too few arguments to function %qE", function); + inform_declaration (fundecl); + return -1; + } } return error_args ? -1 : (int) parmnum; @@ -3875,6 +3907,7 @@ lvalue_p (const_tree ref) case INDIRECT_REF: case ARRAY_REF: + case ARRAY_NOTATION_REF: case VAR_DECL: case PARM_DECL: case RESULT_DECL: @@ -8640,11 +8673,25 @@ c_finish_return (location_t loc, tree retval, tree origtype) tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt; bool no_warning = false; bool npc = false; + size_t rank = 0; if (TREE_THIS_VOLATILE (current_function_decl)) warning_at (loc, 0, "function declared % has a % statement"); + if (flag_enable_cilkplus && contains_array_notation_expr (retval)) + { + /* Array notations are allowed in a return statement if it is inside a + built-in array notation reduction function. */ + if (!find_rank (loc, retval, retval, false, &rank)) + return error_mark_node; + if (rank >= 1) + { + error_at (loc, "array notation expression cannot be used as a " + "return value"); + return error_mark_node; + } + } if (retval) { tree semantic_type = NULL_TREE; @@ -8987,6 +9034,13 @@ c_finish_loop (location_t start_locus, tree cond, tree incr, tree body, { tree entry = NULL, exit = NULL, t; + if (flag_enable_cilkplus && contains_array_notation_expr (cond)) + { + error_at (start_locus, "array notation expression cannot be used in a " + "loop%'s condition"); + return; + } + /* If the condition is zero don't generate a loop construct. */ if (cond && integer_zerop (cond)) { @@ -9493,8 +9547,18 @@ build_binary_op (location_t location, enum tree_code code, op1 = default_conversion (op1); } - orig_type0 = type0 = TREE_TYPE (op0); - orig_type1 = type1 = TREE_TYPE (op1); + /* When Cilk Plus is enabled and there are array notations inside op0, then + we check to see if there are builtin array notation functions. If + so, then we take on the type of the array notation inside it. */ + if (flag_enable_cilkplus && contains_array_notation_expr (op0)) + orig_type0 = type0 = find_correct_array_notation_type (op0); + else + orig_type0 = type0 = TREE_TYPE (op0); + + if (flag_enable_cilkplus && contains_array_notation_expr (op1)) + orig_type1 = type1 = find_correct_array_notation_type (op1); + else + orig_type1 = type1 = TREE_TYPE (op1); /* The expression codes of the data types of the arguments tell us whether the arguments are integers, floating, pointers, etc. */ diff --git a/gcc/cilkplus.def b/gcc/cilkplus.def new file mode 100644 index 00000000000..cb3824f4ee6 --- /dev/null +++ b/gcc/cilkplus.def @@ -0,0 +1,59 @@ +/* This file contains the definitions and documentation for the + CilkPlus builtins used in the GNU compiler. + Copyright (C) 2013 Free Software Foundation, Inc. + +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 +. */ + +/* Before including this file, you should define a macro: + + DEF_CILKPLUS_BUILTIN (ENUM, NAME, TYPE, ATTRS) + + See builtins.def for details. */ + +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_ADD, + "__sec_reduce_add", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_MUL, + "__sec_reduce_mul", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO, + "__sec_reduce_all_zero", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO, + "__sec_reduce_any_zero", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_MAX, + "__sec_reduce_max", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_MIN, + "__sec_reduce_min", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND, + "__sec_reduce_min_ind", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND, + "__sec_reduce_max_ind", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO, + "__sec_reduce_any_nonzero", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO, + "__sec_reduce_all_nonzero", BT_FN_INT_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE, + "__sec_reduce", BT_FN_INT_PTR_PTR_PTR, ATTR_NULL) +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING, + "__sec_reduce_mutating", BT_FN_INT_PTR_PTR_PTR, ATTR_NULL) +// FIXME: This probably needs to be rewritten as a keyword. +DEF_CILKPLUS_BUILTIN (BUILT_IN_CILKPLUS_SEC_IMPLICIT_INDEX, + "__sec_implicit_index", BT_FN_INT_INT, ATTR_NULL) + +/* +Local variables: +mode:c +End: +*/ diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 5c5b4b44fd7..c71924ba6dd 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -82,6 +82,7 @@ extensions, accepted by GCC in C90 mode and in C++. * x86 specific memory model extensions for transactional memory:: x86 memory models. * Object Size Checking:: Built-in functions for limited buffer overflow checking. +* Cilk Plus Builtins:: Built-in functions for the Cilk Plus language extension. * Other Builtins:: Other built-in functions. * Target Builtins:: Built-in functions specific to particular targets. * Target Format Checks:: Format checks specific to particular targets. @@ -8788,6 +8789,32 @@ Similar to @code{__builtin_bswap32}, except the argument and return types are 64 bit. @end deftypefn +@node Cilk Plus Builtins +@section Cilk Plus C/C++ language extension Built-in Functions. + +GCC provides support for the following built-in reduction funtions if Cilk Plus +is enabled. Cilk Plus can be enabled using the @option{-fcilkplus} flag. + +@itemize @bullet +@item __sec_implicit_index +@item __sec_reduce +@item __sec_reduce_add +@item __sec_reduce_all_nonzero +@item __sec_reduce_all_zero +@item __sec_reduce_any_nonzero +@item __sec_reduce_any_zero +@item __sec_reduce_max +@item __sec_reduce_min +@item __sec_reduce_max_ind +@item __sec_reduce_min_ind +@item __sec_reduce_mul +@item __sec_reduce_mutating +@end itemize + +Further details and examples about these built-in functions are described +in the Cilk Plus language manual which can be found at +@uref{http://www.cilkplus.org}. + @node Target Builtins @section Built-in Functions Specific to Particular Target Machines diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index b0fff0db4de..06c55fe4808 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -1799,6 +1799,17 @@ Program Interface v3.0 @w{@uref{http://www.openmp.org/}}. This option implies @option{-pthread}, and thus is only supported on targets that have support for @option{-pthread}. +@item -fcilkplus +@opindex fcilkplus +@cindex Enable Cilk Plus +Enable the usage of Cilk Language extension features for C/C++. When the flag +@option{-fcilkplus} is specified, all the Cilk Plus components are converted +to the appropriate C/C++ code. The present implementation follows ABI version +0.9. There are four major parts to Cilk Plus language +extension: Array Notations, Cilk Keywords, SIMD annotations and elemental +functions. Detailed information about Cilk Plus can be found at +@w{@uref{http://www.cilkplus.org}}. + @item -fgnu-tm @opindex fgnu-tm When the option @option{-fgnu-tm} is specified, the compiler diff --git a/gcc/doc/passes.texi b/gcc/doc/passes.texi index 654f2295e39..045f964a939 100644 --- a/gcc/doc/passes.texi +++ b/gcc/doc/passes.texi @@ -17,6 +17,7 @@ where near complete. @menu * Parsing pass:: The language front end turns text into bits. +* Cilk Plus Transformation:: Transform Cilk Plus Code to equivalent C/C++. * Gimplification pass:: The bits are turned into something we can optimize. * Pass manager:: Sequencing the optimization passes. * Tree SSA passes:: Optimizations on a high-level representation. @@ -101,6 +102,36 @@ that is more descriptive than "rest_of". The middle-end will, at its option, emit the function and data definitions immediately or queue them for later processing. +@node Cilk Plus Transformation +@section Cilk Plus Transformation +@cindex CILK_PLUS + +If Cilk Plus generation (flag @option{-fcilkplus}) is enabled, all the Cilk +Plus code is transformed into equivalent C and C++ functions. Majority of this +transformation occurs toward the end of the parsing and right before the +gimplification pass. + +These are the major components to the Cilk Plus language extension: +@itemize @bullet +@item Array Notations: +During parsing phase, all the array notation specific information is stored in +@code{ARRAY_NOTATION_REF} tree using the function +@code{c_parser_array_notation}. During the end of parsing, we check the entire +function to see if there are any array notation specific code (using the +function @code{contains_array_notation_expr}). If this function returns +true, then we expand them using either @code{expand_array_notation_exprs} or +@code{build_array_notation_expr}. For the cases where array notations are +inside conditions, they are transformed using the function +@code{fix_conditional_array_notations}. The C language-specific routines are +located in @file{c/c-array-notation.c} and the equivalent C++ routines are in +file @file{cp/cp-array-notation.c}. Common routines such as functions to +initialize builtin functions are stored in @file{array-notation-common.c}. +@end itemize + +Detailed information about Cilk Plus and language specification is provided in +@w{@uref{http://www.cilkplus.org/}}. It is worth mentioning that the current +implementation follows ABI 0.9. + @node Gimplification pass @section Gimplification pass diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index cbf3d326149..869371a1edd 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,45 @@ +2013-05-28 Balaji V. Iyer + + * c-c++-common/cilk-plus/AN/array_test1.c: New test. + * c-c++-common/cilk-plus/AN/array_test2.c: Likewise. + * c-c++-common/cilk-plus/AN/array_test_ND.c: Likewise. + * c-c++-common/cilk-plus/AN/builtin_func_double.c: Likewise. + * c-c++-common/cilk-plus/AN/builtin_func_double2.c: Likewise. + * c-c++-common/cilk-plus/AN/gather-scatter-errors.c: Likewise. + * c-c++-common/cilk-plus/AN/if_test.c: Likewise. + * c-c++-common/cilk-plus/AN/sec_implicit_ex.c: Likewise. + * c-c++-common/cilk-plus/AN/decl-ptr-colon.c: Likewise. + * c-c++-common/cilk-plus/AN/dimensionless-arrays.c: Likewise. + * c-c++-common/cilk-plus/AN/fn_ptr.c: Likewise. + * c-c++-common/cilk-plus/AN/fp_triplet_values.c: Likewise. + * c-c++-common/cilk-plus/AN/gather-scatter.c: Likewise. + * c-c++-common/cilk-plus/AN/misc.c: Likewise. + * c-c++-common/cilk-plus/AN/parser_errors.c: Likewise. + * c-c++-common/cilk-plus/AN/parser_errors2.c: Likewise. + * c-c++-common/cilk-plus/AN/parser_errors3.c: Likewise. + * c-c++-common/cilk-plus/AN/parser_errors4.c: Likewise. + * c-c++-common/cilk-plus/AN/rank_mismatch.c: Likewise. + * c-c++-common/cilk-plus/AN/rank_mismatch2.c: Likewise. + * c-c++-common/cilk-plus/AN/rank_mismatch3.c: Likewise. + * c-c++-common/cilk-plus/AN/sec_implicit.c: Likewise. + * c-c++-common/cilk-plus/AN/sec_implicit2.c: Likewise. + * c-c++-common/cilk-plus/AN/sec_reduce_max_min_ind.c: Likewise. + * c-c++-common/cilk-plus/AN/tst_lngth.c: Likewise. + * c-c++-common/cilk-plus/AN/vla.c: Likewise. + * c-c++-common/cilk-plus/AN/an-if.c: Likewise. + * c-c++-common/cilk-plus/AN/builtin_fn_custom.c: Likewise. + * c-c++-common/cilk-plus/AN/builtin_fn_mutating.c: Likewise. + * c-c++-common/cilk-plus/AN/comma_exp.c: Likewise. + * c-c++-common/cilk-plus/AN/conditional.c: Likewise. + * c-c++-common/cilk-plus/AN/exec-once.c: Likewise. + * c-c++-common/cilk-plus/AN/exec-once2.c: Likewise. + * c-c++-common/cilk-plus/AN/gather_scatter.c: Likewise. + * c-c++-common/cilk-plus/AN/n-ptr-test.c: Likewise. + * c-c++-common/cilk-plus/AN/side-effects-1.c: Likewise. + * c-c++-common/cilk-plus/AN/test_builtin_return.c: Likewise. + * c-c++-common/cilk-plus/AN/test_sec_limits.c: Likewise. + * gcc.dg/cilk-plus/cilk-plus.exp: New script. + 2013-05-28 Tobias Burnus PR fortran/37336 diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/an-if.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/an-if.c new file mode 100644 index 00000000000..4bf85b5ca93 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/an-if.c @@ -0,0 +1,48 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#if HAVE_IO +#include +#endif +#include + +const int n = 8; + +float x[8], y[8], z[8]; + +int main() { + int i = 0; + float x_sum =0; + for(i=1; i<=5; i+=4 ) { + x[0:n] = 3; + y[0:n] = i; + z[0:n] = 0; +#if HAVE_IO + printf("x\ty\tz\n"); + for( size_t k=0; k= y[0:n]) { + z[0:n] = x[0:n] - y[0:n]; + } else { + z[0:n] = x[0:n] + y[0:n]; + } +#if HAVE_IO + printf("x\ty\tz\n"); + for( size_t k=0; k=i?3-i:3+i)*n ); + } + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test1.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test1.c new file mode 100644 index 00000000000..bdd271a7730 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test1.c @@ -0,0 +1,90 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +#include + +int main2 (int argc, char **argv); + +int main(int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "5"}; + x = main2 (2, (char **)array); + } + else + x = main2 (argc, argv); + + return x; +} + +int main2 (int argc, char **argv) +{ + int array[10], ii = 0, x = 2, z= 0 , y = 0 ; + for (ii = 0; ii < 10; ii++) + array[ii] = 10; + + array[0:10:1] = 15; + + for (ii = 0; ii < 10; ii++) + if (array[ii] != 15) + return 5; + array[0:5:2] = 20; + + for (ii = 0; ii < 10; ii += 2) + if (array[ii] != 20) + return 4; + + + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + + array[x:5:z] = 50; + + for (ii = x; ii < 10; ii += z) + if (array[ii] != 50) + return 3; + + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + y = 10-atoi(argv[1]); + + array[x:y:z] = 505; + for (ii = x; ii < 10; ii += z) + if (array[ii] != 505) + return 2; + + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + y = 10-atoi(argv[1]); + + array[x:y:((10-atoi(argv[1]))/atoi(argv[1]))] = 25; + + for (ii = x; ii < 10; ii += z) + if (array[ii] != 25) + return 1; + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + y = 10-atoi(argv[1]); + + array[atoi(argv[1]):(10-atoi(argv[1])):((10-atoi(argv[1]))/atoi(argv[1]))] = + 1400; + for (ii = x; ii < 10; ii += z) + if (array[ii] != 1400) + return 1; + + + array[atoi("5"):5:1] = 5555; + + for (ii = atoi ("5"); ii < 10; ii++) + if (array[ii] != 5555) + return 2; + + + array[atoi("5"):atoi("5"):atoi("1")] = 9999; + for (ii = atoi ("5"); ii < (atoi ("5") + atoi ("5")); ii += atoi ("1")) + if (array[ii] != 9999) + return 3; + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test2.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test2.c new file mode 100644 index 00000000000..bd7a4ad2b62 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test2.c @@ -0,0 +1,134 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#include +int main2(int argc, char **argv); +int main(int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "5"}; + x = main2 (2, (char **)array); + } + else + x = main2 (argc, argv); + + return x; +} + + +int main2(int argc, char **argv) +{ + int array[10], array2[10], ii = 0, x = 2, z= 0 , y = 0 ; + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 10; + array2[ii] = 5000000; + } + + array2[0:10:1] = array[0:10:1]; + + for (ii = 0; ii < 10; ii++) + if (array2[ii] != array[ii]) + return 1; + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 10; + array2[ii] = 5000000; + } + + array2[0:5:2] = array[0:5:2]; + + for (ii = 0; ii < 10; ii += 2) + if (array[ii] != array2[ii]) + return 2; + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 10; + array2[ii] = 5000000; + } + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + + array2[x:5:z] = array[x:5:z]; + + for (ii = x; ii < 5; ii += z) + if (array2[ii] != array[ii]) + return 3; + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 500; + array2[ii] = 1000000; + } + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + y = 10-atoi(argv[1]); + + array2[x:y:z] = array[x:y:z]; + for (ii = x; ii < 10; ii = ii + z) + if (array2[ii] != array[ii]) + return 4; + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 500; + array2[ii] = 1000000; + } + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + y = 10-atoi(argv[1]); + + array[x:y:((10-atoi(argv[1]))/atoi(argv[1]))] = + array2[x:y:((10-atoi(argv[1]))/atoi(argv[1]))]; + + for (ii = x; ii < 10; ii += z) + if (array[ii] != array2[ii]) + return 5; + + + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + y = 10-atoi(argv[1]); + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 500; + array2[ii] = 1000000; + } + + array[atoi(argv[1]):(10-atoi(argv[1])):((10-atoi(argv[1]))/atoi(argv[1]))] = + array2[atoi(argv[1]):(10-atoi(argv[1])):((10-atoi(argv[1]))/atoi(argv[1]))]; + for (ii = x; ii < 10; ii += z) + if (array[ii] != array2[ii]) + return 6; + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 4; + array2[ii] = 2; + } + + array[atoi("5"):5:1] = array2[atoi("5"):5:1]; + + for (ii = atoi ("5"); ii < 10; ii++) + if (array[ii] != array2[ii]) + return (7); + + for (ii = 0; ii < 10; ii++) + { + array[ii] = 5; + array2[ii] = 1; + } + array[atoi("5"):atoi("5"):atoi("1")] = array2[atoi("5"):atoi("5"):atoi("1")]; + + for (ii = 5; ii < 10; ii++) + if (array2[ii] != array[ii]) + return 8; + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test_ND.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test_ND.c new file mode 100644 index 00000000000..1431c22b261 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/array_test_ND.c @@ -0,0 +1,109 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#include +int main2(int argc, char **argv); +int main(int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "10", "15"}; + x = main2 (3, (char **)array); + } + else if (argc == 3) + x = main2 (argc, argv); + else + return 1; + + return x; +} + +int main2(int argc, char **argv) +{ + int array[10][15], ii = 0, jj = 0,x = 0, z= 1 , y = 10 ; + int array_2[10][15]; + + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj< 15; jj++) { + array[ii][jj] = ii+jj; + array_2[ii][jj] = 0; + } + } + array_2[0:5:2][0:5:3] = array[0:5:2][0:5:3] + 1 + 5 + array[0][5] + x; + + for (ii = 0; ii < 10; ii += 2) + { + for (jj = 0; jj < 15; jj += 3) + { + if (array_2[ii][jj] != array[ii][jj] + 1 + 5 + array[0][5] + x) + return 2; + } + } + + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj< 15; jj++) { + array[ii][jj] = ii+jj; + array_2[ii][jj] = 0; + } + } + x = atoi(argv[1]); + y = atoi(argv[2]); + array_2[0:x:1][0:y:1] = array[0:x:1][0:y:1] + x + y + array[0:x:1][0:y:1]; + + for (ii = 0; ii < x; ii++) + { + for (jj = 0; jj < y; jj++) + { + if (array_2[ii][jj] != array[ii][jj] + x + y + array[ii][jj]) + return 3; + } + } + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj< 15; jj++) { + array[ii][jj] = ii+jj; + array_2[ii][jj] = 0; + } + } + x = atoi(argv[1]); + y = atoi(argv[2]); + z = (20- atoi (argv[1]))/atoi(argv[1]); + /* (20-10)/10 evaluates to 1 all the time :-). */ + array_2[0:x:z][0:y:z] = array[0:x:z][0:y:z] + array[0:x:z][0:y:z] + y + z; + + for (ii = 0; ii < x; ii += z) + { + for (jj = 0; jj < y; jj += z) + { + if (array_2[ii][jj] != array[ii][jj] + array[ii][jj] + y + z) + return 4; + } + } + + + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj< 15; jj++) { + array[ii][jj] = ii+jj; + array_2[ii][jj] = 0; + } + } + x = argc-3; + y = 20-atoi(argv[1]); + z = (20- atoi (argv[1]))/atoi(argv[1]); + /* (20-10)/10 evaluates to 1 all the time :-). */ + array_2[(argc-3):(20-atoi(argv[1])):(20-atoi(argv[1]))/atoi(argv[1])][(argc-3):(30-atoi(argv[2])): ((30-atoi(argv[2]))/atoi(argv[2]))] = array[(argc-3):20-atoi(argv[1]):(20-atoi(argv[1]))/atoi(argv[1])][(argc-3):(30-atoi(argv[2])): (30-atoi(argv[2]))/atoi(argv[2])] + array[(argc-3):20-atoi(argv[1]):(20-atoi(argv[1]))/atoi(argv[1])][(argc-3):(30-atoi(argv[2])): (30-atoi(argv[2]))/atoi(argv[2])] * array[(argc-3):20-atoi(argv[1]):(20-atoi(argv[1]))/atoi(argv[1])][(argc-3):(30-atoi(argv[2])): (30-atoi(argv[2]))/atoi(argv[2])]; + + for (ii = 0; ii < 10; ii++) + { + for (jj = 0; jj < 15; jj++) + { + if (array_2[ii][jj] != array[ii][jj] + array[ii][jj] * array[ii][jj]) + return 5; + } + } + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_fn_custom.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_fn_custom.c new file mode 100644 index 00000000000..8bdf1fd3ca1 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_fn_custom.c @@ -0,0 +1,68 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#if HAVE_IO +#include +#endif +/* #include */ + +double my_func (double x, double y) +{ + if (x > y) + return x; + else + return y; +} + + +/* char __sec_reduce_add (int *); */ +int main(int argc, char **argv) +{ + int ii,array[10], y = 0, y_int = 0, array2[10]; + double x, yy, array3[10], array4[10]; + double max_value = 0.000, min_value = 0.000, add_value, mul_value = 1.00; + int max_index = 0, min_index = 0; + for (ii = 0; ii < 10; ii++) + { + array[ii] = 1+ii; + array2[ii]= 2; + } + + for (ii = 0; ii < 10; ii++) + { + if (ii%2 && ii) + array3[ii] = (double)(1.0000/(double)ii); + else + array3[ii] = (double) ii + 0.10; + array4[ii] = (double) (1.00000/ (double)(ii+1)); + } + + /* array[:] = 5; */ + x = __sec_reduce (0, array3[:] * array4[:], my_func); + y = __sec_reduce_max_ind ( array3[:] * array4[:]); + + /* Initialize it to the first variable. */ + max_value = array3[0] * array4[0]; + for (ii = 0; ii < 10; ii++) + if (array3[ii] * array4[ii] > max_value) { + max_value = array3[ii] * array4[ii]; + max_index = ii; + } + + + +#if HAVE_IO + for (ii = 0; ii < 10; ii++) + printf("%5.3f ", array3[ii] * array4[ii]); + printf("\n"); + printf("Max = %5.3f\t Max Index = %2d\n", x, y); +#endif + + if (x != max_value) + return 1; + + if (y != max_index) + return 2; + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_fn_mutating.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_fn_mutating.c new file mode 100644 index 00000000000..34cbd2c4cc3 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_fn_mutating.c @@ -0,0 +1,68 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#if HAVE_IO +#include +#endif +/* #include */ + +void my_func (double *x, double y) +{ + if (*x < y) + *x = y; +} + + +int main(int argc, char **argv) +{ + int ii,array[10], y = 0, y_int = 0, array2[10]; + double x = 0.000, yy, array3[10], array4[10]; + double max_value = 0.000, min_value = 0.000, add_value, mul_value = 1.00; + int max_index = 0, min_index = 0; +#if 1 + for (ii = 0; ii < 10; ii++) + { + array[ii] = 1+ii; + array2[ii]= 2; + } + + for (ii = 0; ii < 10; ii++) + { + if (ii%2 && ii) + array3[ii] = (double)(1.0000/(double)ii); + else + array3[ii] = (double) ii + 0.10; + array4[ii] = (double) (1.00000/ (double)(ii+1)); + } +#endif + /* array[:] = 5; */ + __sec_reduce_mutating (&x, array3[:] * array4[:], my_func); +#if 1 + y = __sec_reduce_max_ind ( array3[:] * array4[:]); + + /* Initialize it to the first variable. */ + max_value = array3[0] * array4[0]; + for (ii = 0; ii < 10; ii++) + if (array3[ii] * array4[ii] > max_value) { + max_value = array3[ii] * array4[ii]; + max_index = ii; + } + + + +#if HAVE_IO + for (ii = 0; ii < 10; ii++) + printf("%5.3f ", array3[ii] * array4[ii]); + printf("\n"); + printf("Max = %5.3f\t Max Index = %2d\n", x, y); + printf("Max = %5.3f\t Max Index = %2d\n", max_value, max_index); +#endif + + if (x != max_value) + return 1; + + if (y != max_index) + return 2; +#endif + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_func_double.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_func_double.c new file mode 100644 index 00000000000..c6b518e6229 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_func_double.c @@ -0,0 +1,124 @@ +#if HAVE_IO +#include +#endif +/* #include */ + +/* char __sec_reduce_add (int *); */ +int main(int argc, char **argv) +{ + int ii,array[10], y = 0, y_int = 0, array2[10]; + double x, yy, array3[10], array4[10]; + double max_value = 0.000, min_value = 0.000, add_value, mul_value = 1.00; + int max_index = 0, min_index = 0; + for (ii = 0; ii < 10; ii++) + { + array[ii] = 1+ii; + array2[ii]= 2; + } + + for (ii = 0; ii < 10; ii++) + { + if (ii%2 && ii) + array3[ii] = (double)(1.0000/(double)ii); + else + array3[ii] = (double) ii + 0.10; + array4[ii] = (double) (1.00000/ (double)(ii+1)); + } + + /* array[:] = 5; */ + x = __sec_reduce_max (array3[:] * array4[:]); + y = __sec_reduce_max_ind ( array3[:] * array4[:]); + + /* Initialize it to the first variable. */ + max_value = array3[0] * array4[0]; + for (ii = 0; ii < 10; ii++) + if (array3[ii] * array4[ii] > max_value) { + max_value = array3[ii] * array4[ii]; + max_index = ii; + } + + + +#if HAVE_IO + for (ii = 0; ii < 10; ii++) + printf("%5.3f ", array3[ii] * array4[ii]); + printf("\n"); + printf("Max = %5.3f\t Max Index = %2d\n", x, y); +#endif + + if (x != max_value) + return 1; + + if (y != max_index) + return 2; + + x = __sec_reduce_min (array3[:] * array4[:]); + y = __sec_reduce_min_ind ( array3[:] * array4[:]); +#if HAVE_IO + for (ii = 0; ii < 10; ii++) + printf("%5.3f ", array3[ii] * array4[ii]); + printf("\n"); + printf("Min = %5.3f\t Min Index = %2d\n", x, y); +#endif + + /* Initialize it to the first variable. */ + min_value = array3[0] * array4[0]; + for (ii = 0; ii < 10; ii++) + if (array3[ii] * array4[ii] < min_value) { + min_value = array3[ii] * array4[ii]; + min_index = ii; + } + + if (x != min_value) + return 3; + if (y != min_index) + return 4; + + x = __sec_reduce_add (array3[:] * array4[:]); + yy = __sec_reduce_mul ( array3[:] * array4[:]); +#if HAVE_IO + for (ii = 0; ii < 10; ii++) + printf("%5.3f ", array3[ii] * array4[ii]); + printf("\n"); + printf("Add = %5.3f\t Mul = %f\n", x, yy); +#endif + + /* Initialize it to the first variable. */ + add_value = 0.0000; + mul_value = 1.0000; + for (ii = 0; ii < 10; ii++) + { + add_value += (array3[ii] * array4[ii]); + mul_value *= (array3[ii] * array4[ii]); + } + + if (x != add_value) + return 5; + if (yy != mul_value) + return 6; + + for (ii = 0; ii < 10; ii++) + { + if (ii%2 && ii) + array3[ii] = (double)(1.0000/(double)ii); + else + array3[ii] = (double) ii + 0.00; + array4[ii] = (double) (1.00000/ (double)(ii+1)); + } + y_int = __sec_reduce_any_zero (array3[:] * array4[:]); + y = __sec_reduce_all_zero ( array3[:] * array4[:]); + + if (y_int != 1) + return 7; + + if (y != 0) + return 8; + +#if HAVE_IO + for (ii = 0; ii < 10; ii++) + printf("%5.3f ", array3[ii] * array4[ii]); + printf("\n"); + printf("Any Zeros = %d\t All Zeros = %d\n", y_int, y); +#endif + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_func_double2.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_func_double2.c new file mode 100644 index 00000000000..c8a3ed7880f --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/builtin_func_double2.c @@ -0,0 +1,74 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#if HAVE_IO +#include +#endif + +int main(int argc, char **argv) +{ + int ii,array[10], y = 0, y_int = 0, array2[10], y_int2=0, y2=0; + double x, yy, array3[10], array4[10]; + int all_zero, all_nonzero, any_zero, any_nonzero; + for (ii = 0; ii < 10; ii++) + { + array[ii] = 0; + array2[ii] = 5; + if (ii%2 && ii) + array3[ii] = (double)(1.0000/(double)ii); + else + array3[ii] = (double) ii + 0.00; + array4[ii] = (double) (1.00000/ (double)(ii+1)); + } + y_int = __sec_reduce_any_nonzero (array3[:] + array[4]); + y_int2 = __sec_reduce_any_zero (array3[:] + array[4]); + y = __sec_reduce_all_nonzero ((array3[:] + array4[:]) * (argc-1)); + y2 = __sec_reduce_all_zero ((array3[:] + array4[:]) * (argc-1)); + + any_zero = 0; + any_nonzero = 0; + for (ii = 0; ii < 10; ii++) + { + if ((array3[ii] + array[4]) == 0) + any_zero = 1; + else + any_nonzero = 1; + } + + if (any_nonzero != y_int) + return 1; + if (any_zero != y_int2) + return 2; + + + all_zero = 0; + all_nonzero = 0; + for (ii = 0; ii < 10; ii++) + { + if (((array3[ii] + array4[ii]) * (argc-1)) == 0) + all_zero = 1; + else + all_nonzero = 1; + } + + if (y != all_nonzero) + return 3; + if (all_zero != y2) + return 4; + + +#if HAVE_IO + for (ii = 0; ii < 10; ii++) { + printf("%5.3f ", array3[ii] +array4[ii]); + } + printf("\n"); + for (ii = 0; ii < 10; ii++) { + printf("%5.3f ", (array3[ii] + array4[ii]) * (argc-1)); + } + printf("\n"); + printf("Any Non-zeros (1st line) = %d\t All non-zeros (1st line) = %d\n", + y_int, y); + printf("Any zeros (2nd line) = %d\t All zeros (2nd line) = %d\n", y_int2, y2); +#endif + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/comma_exp.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/comma_exp.c new file mode 100644 index 00000000000..bcb3e1b1612 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/comma_exp.c @@ -0,0 +1,60 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#include + +int main2 (int argc, char **argv); +int main(int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "5"}; + x = main2 (2, (char **)array); + } + else + x = main2 (argc, argv); + + return x; +} + +int main2 (int argc, char **argv) +{ + int array[10], array2[10], ii = 0, x = 2, z= 0 , y = 0 ; + + for (ii = 0; ii < 10; ii++) + array[ii] = 10; + + for (ii = 0; ii < 10; ii++) + array2[ii] = 1; + + array[0:10:1] = (array[:], 15); + + for (ii = 0; ii < 10; ii++) + if (array[ii] != 15) + return 1; + array[0:5:2] = (argc+2, 20); + + for (ii = 0; ii < 10; ii += 2) + if (array[ii] != 20) + return 2; + + + x = atoi(argv[1]); + z = (10-atoi(argv[1]))/atoi(argv[1]); + + array[x:5:z] = 50; + + array[:] = (atoi(argv[1]), (array2[0:10]+5)); + + for (ii = 0; ii < 10; ii++) + if (array[ii] != 6) + return (3); + + array[:] = (atoi(argv[1]), (array2[0:10]+array2[0:10])); + for (ii = 0; ii < 10; ii++) + if (array[ii] != 2) + return 4; + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/conditional.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/conditional.c new file mode 100644 index 00000000000..0be99b2102b --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/conditional.c @@ -0,0 +1,42 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#include +int main(int argc, char **argv) +{ + short array[1000], array2[1000], *array3, cond[1000], ii = 0; + + for (ii = 0; ii < 1000; ii++) { + cond[ii] = 1; + array[ii] = 1000; + array2[ii] = 2000; + } + array2[:] = cond[:] ? array[:] : array2[:]; + + for (ii = 0; ii < 1000; ii++) { + if (array2[ii] != 1000) + return 1; + } + + array2[0:500:2] = cond[0:500] ? array[0:500:1] : array2[0:500:2]; + + for (ii = 0; ii < 1000; ii++) { + if (array2[ii] != 1000) + return 2; + } + + for (ii = 0; ii < 1000; ii++) { + cond[ii] = ii % 2; /* This should give 0, 1, 0, 1, 0, 1, 0,... */ + array2[ii] = 5; + array[ii] = 3; + } + array3 = (short *) malloc (sizeof (short) * 1000); + array3[0:1000:argc] = cond[:] ? array[0:(argc * 1000)] : array2[argc-1:1000]; + + for (ii = 0; ii < 1000; ii++) { + if ((cond[ii] == 0 && array3[ii] != 5) + || (cond[ii] == 1 && array3[ii] != 3)) + return 3; + } + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/decl-ptr-colon.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/decl-ptr-colon.c new file mode 100644 index 00000000000..68c88590da2 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/decl-ptr-colon.c @@ -0,0 +1,18 @@ +/* { dg-options "-fcilkplus" } */ + +int main(void) +{ + extern int func(int); + int array3[:], x, q; /* { dg-error "array notations cannot be used in declaration" } */ + int array3[1:2:x]; /* { dg-error "array notations cannot be used in declaration" } */ + extern char array3[1:func(x)]; /* { dg-error "array notations cannot be used in declaration" } */ + int *a, ***b; + extern char *c; + int array2[10]; + + a[:] = 5; /* { dg-error "start-index and length fields necessary for using array notations in pointers" } */ + c[1:2] = 3; /* This is OK. */ + (array2)[:] = 5; /* This is OK. */ + b[1:2][1:func(x)][:] = 3; /* { dg-error "start-index and length fields necessary for using array notations in pointers" } */ +} + diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/dimensionless-arrays.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/dimensionless-arrays.c new file mode 100644 index 00000000000..69aaa523727 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/dimensionless-arrays.c @@ -0,0 +1,10 @@ +/* { dg-options "-fcilkplus" } */ + +extern int a[]; +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" } +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/exec-once.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/exec-once.c new file mode 100644 index 00000000000..4b2a09f48b0 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/exec-once.c @@ -0,0 +1,44 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#define NUMBER 1000 + +#if HAVE_IO +#include +#endif + +int func (int *x) +{ + int q = *x; + q++; + *x = q; +#if HAVE_IO + printf("%d\n", (q)); +#endif + return *x; +} +int main (int argc, char **argv) +{ + char array[NUMBER], array2[NUMBER]; + int ii, d = 2; +#if 1 + for (ii = 0; ii < NUMBER; ii++) { + array[ii] = 5; + array2[ii]= 2; + } +#endif + d = func (&d); /* d = 1 */ + array2[:] = d * array[:] + (char) func (&d); /* 3 * 5 + 4 */ +#if HAVE_IO + for (ii = 0; ii < NUMBER; ii++) + printf("array2[%d] = %d\n", ii, array2[ii]); +#endif + for (ii = 0; ii < NUMBER; ii++) + if (array2[ii] != (3 * 5 + 4)) + return 1; + + return 0; +} + + + diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/exec-once2.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/exec-once2.c new file mode 100644 index 00000000000..8d208b92c8f --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/exec-once2.c @@ -0,0 +1,85 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#ifdef HAVE_IO +#include +#endif + + +int func1(int x) +{ + /* If x == 2 then it should return 0. */ + return (x - 2); +} + +int func2(int x) +{ + /* If x == 2 then it should return 1000. */ + return (x * 500); +} + +int func3 (int x) +{ + /* If x == 2 then it should return 1. */ + /* If x == 1 then it should return 0. */ + return (x-1); +} + +int func4(int x) +{ + if (x > 0) + return x; + else + return x--; +} + + +/* This program makes an assumption that argc == 1. */ +int main (int argc, char **argv) +{ + + int array[2500]; + + /* This should set array[0->999] to 5. */ + array[argc-1:func2(++argc):1] = 5; + array[1000:500:1] = 10; /* set all variables in array[1000-->1499] to 10. */ + array[1500:500:1] = 15; /* set all variables in array[1500-->1999] to 15. */ + array[2000:500:1] = 20; /* set all variables in array[2000-->2499] to 20. */ + array[2000:500:1] = 25; /* set all variables in array[2500-->2999] to 25. */ + array[2000:500:1] = 30; /* set all variables in array[3000-->3499] to 30. */ + + argc = func3 (argc); /* This will set argc back to 1. */ +#if HAVE_IO + printf("argc = %d\n", argc); +#endif + /* If the parameters inside the function get evaluated only once, then this + if statement must work fine, i.e. the triplet values will be 0, 1000, 1. + + Otherwise, the program should crash or give some uneasy value. */ + + /* If done correctly, it should boil down to: array[0:1000:1]. */ + if (array[func3(argc):func2(++argc)] != 5) { +#ifdef HAVE_IO + printf ("Should not be there(1).\n"); +#endif + return 1; + } + + /* If done correctly, it should boil down to: array[999:500:-1]. */ + if (func4(array[func2(argc)-1:func2(argc--):func1(argc)]) != 5) { +#ifdef HAVE_IO + printf ("Should not be there(2).\n"); +#endif + return 2; + } + + /* If done correctly, it should boil down to: array[1000:500:1]. */ + if (func4 (func4(array[func2(argc++):500: func1(argc--)])) != 5) { +#ifdef HAVE_IO + printf ("Should not be there(3).\n"); +#endif + return 3; + } + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/fn_ptr.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/fn_ptr.c new file mode 100644 index 00000000000..1010920b3aa --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/fn_ptr.c @@ -0,0 +1,19 @@ +/* { dg-options "-fcilkplus" } */ + +typedef int (*foo)(int); + +int main(int argc, char **argv) +{ + int array[10], array2[10][10]; + foo func_array[10]; + foo func_array2[10][10]; + foo ***func_array_ptr; + + 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" } */ + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/fp_triplet_values.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/fp_triplet_values.c new file mode 100644 index 00000000000..cb504f309ed --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/fp_triplet_values.c @@ -0,0 +1,43 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +float q; + +int main2 (int argc, char **argv); +int main (int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "5"}; + x = main2 (2, (char **)array); + } + else + x = main2 (argc, argv); + + return x; +} + +void func (int *x) +{ + *x = 5; +} + +int main2 (int argc, char **argv) +{ + int array[10], array2[10]; + array2[:] = array[1.5:2]; /* { dg-error "start-index of array notation triplet is not an integer" } */ + array2[:] = array[1:2.32333333333]; /* { dg-error "length of array notation triplet is not an integer" } */ + array2[1:2:1.5] = array[:]; /* { dg-error "stride of array notation triplet is not an integer" } */ + func (&array2[1:2.34:3]); /* { dg-error "length of array notation triplet is not an integer" } */ + array2[1.43:9]++; /* { dg-error "start-index of array notation triplet is not an integer" } */ + array2[1:9.3]++; /* { dg-error "length of array notation triplet is not an integer" } */ + array2[1:9:0.3]++; /* { dg-error "stride of array notation triplet is not an integer" } */ + + ++array2[1:q:3]; /* { dg-error "length of array notation triplet is not an integer" } */ + array2[:] = array[q:1:3]; /* { dg-error "start-index of array notation triplet is not an integer" } */ + array2[:] = array[1:q:3]; /* { dg-error "length of array notation triplet is not an integer" } */ + array2[:] = array[1:3:q]; /* { dg-error "stride of array notation triplet is not an integer" } */ + func (&array2[1:q:3]); /* { dg-error "length of array notation triplet is not an integer" } */ + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/gather-scatter-errors.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/gather-scatter-errors.c new file mode 100644 index 00000000000..f4283dbf11f --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/gather-scatter-errors.c @@ -0,0 +1,19 @@ +/* { dg-options "-fcilkplus" } */ + +int main (int argc, char **argv) +{ + extern int func (int); + int array[10][10], array2[10]; + + array2[array[:][:]] = 5; /* { dg-error "rank of the array's index is greater than 1" } */ + + array2[array[:][:]] = 5; /* { dg-error "rank of the array's index is greater than 1" } */ + func (array2[array[:][:]]); /* { dg-error "rank of the array's index is greater than 1" } */ + func (array2[array[argc:func(5)][0:10:2]]); /* { dg-error "rank of the array's index is greater than 1" } */ + + array[array2[:]][array2[:]] = 5; /* This is OK. */ + array[array2[:]][array2[:]] = array2[array[:][:]]; /* { dg-error "rank of the array's index is greater than 1" } */ + array[array2[:]][array2[:]] = array2[array[0:10:1][:]]; /* { dg-error "rank of the array's index is greater than 1" } */ + array[array2[:]][array2[:]] = array2[array[:][argc:func (argc)]]; /* { dg-error "rank of the array's index is greater than 1" } */ + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/gather_scatter.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/gather_scatter.c new file mode 100644 index 00000000000..67e1c19d6cc --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/gather_scatter.c @@ -0,0 +1,59 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#if HAVE_IO +#include +#endif + +int main(int argc, char **argv) +{ + int array[10][10], array2[10], array3[10], x = 0, y; + int x_correct, y_correct, ii, jj = 0; + float array4[10][10][10][10]; + for (ii = 0; ii < 10; ii++) + { + for (jj = 0; jj < 10; jj++) + { + array[ii][jj] = 1+ii; + array2[ii]= 2; + array3[ii]= 3; + } + } + + array[array2[:]][array3[:]] = 1000; + + for (ii = 0; ii < 10; ii++) + if (array[array2[ii]][array3[ii]] != 1000) + return 1; + +#if HAVE_IO + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj < 10; jj++) { + printf("%4d\t", array[ii][jj]); + } + printf("\n"); + } +#endif + + array4[array2[:]][array3[0:10:1]][array2[0:10:1]][array3[0:10:1]] = + (float)array[array2[:]][array3[:]]; + + for (ii = 0; ii < 10; ii++) + if (array4[array2[ii]][array3[ii]][array2[ii]][array3[ii]] != + (float)array[array2[ii]][array3[ii]]) + return 2; + +#if HAVE_IO + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj < 10; jj++) { + for (kk = 0; kk < 10; kk++) { + for (ll = 0; ll < 10; ll++) { + printf("%4d\n", array4[ii][jj][kk][ll]); + } + } + } + } +#endif + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/if_test.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/if_test.c new file mode 100644 index 00000000000..b150b18f297 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/if_test.c @@ -0,0 +1,250 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#include +int main2 (int argc, char **argv); +int main(int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "10", "15"}; + x = main2 (3, (char **) array); + } + else if (argc == 3) + x = main2 (argc, argv); + else + return 1; + + return x; +} + + +int main2 (int argc, char **argv) +{ + int x = 3, y, z, array[10], array2[10], TwodArray[10][10], jj,kk,ll ; + int array2_check[10]; + int FourDArray[10][10][10][10]; + int ii = 0; + + for (ii = 0; ii < 10; ii++) + { + array[ii] = argc%3; + array2[ii]= 10; + array2_check[ii] = 10; + } + + if (!array[:]) + array2[:] = 5; + else + array2[:] = 10; + + + for (ii = 0; ii < 10; ii++) + { + if (!array[ii]) + array2_check[ii] = 5; + else + array2_check[ii] = 10; + } + + for (ii = 0; ii < 10; ii++) + if (array2_check[ii] != array2[ii]) + return 2; + + + + if (!(array[0:10:1] + array[0:10:1])) + array2[:] = 5; + else + array2[:] = 10; + + for (ii = 0; ii < 10; ii++) + { + if (!(array[ii]+ array[ii])) + array2_check[ii] = 5; + else + array2_check[ii] = 10; + } + + for (ii = 0; ii < 10; ii++) + if (array2_check[ii] != array2[ii]) + return 3; + + + + + + x = atoi (argv[1])-10; + y = atoi (argv[1])/2; + z = (atoi (argv[1]))/5; + + for (ii = 0; ii < 10; ii++) + { + if (ii % 2) + array[ii] = 0; + else + array[ii] = 1; + } + + /*printf("x = %2d y = %2d z = %2d\n", x, y, z); */ + + for (ii = 0; ii < 10; ii++) + array[ii] = 10; + + /* This if loop will change all the 10's to 5's */ + if (array[x:y:z] != 9) + array2[:] = 5; + else + array2[:] = 10; + + for (ii = x; ii < (x+y); ii += z) + { + if (array[ii] != 9) + array2_check[ii] = 5; + else + array2_check[ii] = 10; + } + + for (ii = 0; ii < 10; ii++) + if (array2_check[ii] != array2[ii]) + return 4; + + for (ii = 0; ii < 10; ii++) + array2[ii] = 10; + + /* This if loop will change all the 10's to 5's */ + if (array[atoi(argv[1])-10:atoi(argv[1]): atoi(argv[1])/5]) + array2[:] = 5; + else + array2[:] = 10; + + for (ii = atoi(argv[1])-10; ii < atoi(argv[1]) + (atoi (argv[1])-10); + ii +=atoi(argv[1])/5) + if (array[ii]) + array2_check[ii] = 5; + else + array2_check[ii] = 10; + + for (ii = 0; ii < 10; ii++) + if (array2_check[ii] != array2[ii]) + return 5; + + + for (ii = 0; ii < 10; ii++) + for (jj = 0; jj < 10; jj++) + TwodArray[ii][jj] = atoi(argv[1]); + + + for (ii = 0; ii < 10; ii++) + { + array2[ii] = 10; + array2_check[ii] = 10; + } + + /* atoi(argv[1]) == 10, so it will convert all 10's to 5's */ + if (TwodArray[:][:] != 10) + array2[:] = 10; + else + array2[:] = 5; + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj < 10; jj++) { + if (TwodArray[ii][jj] != 10) + array2_check[ii] = 10; + } + } + + for (ii = 0; ii < 10; ii++) + { + array2[ii] = 10; + array2_check[ii] = 10; + } + + for (ii = 0; ii < 10; ii++) + for (jj = 0; jj < 10; jj++) + for (kk = 0; kk < 10; kk++) + for (ll = 0; ll < 10; ll++) + FourDArray[ii][jj][kk][ll] = atoi(argv[1]); + + /* atoi(argv[1]) == 10, so it will convert all 10's to 5's */ + if (FourDArray[:][:][:][:] != 10) + array2[:] = 10; + else + array2[:] = 5; + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj < 10; jj++) { + for (kk = 0; kk < 10; kk++) { + for (ll = 0; ll < 10; ll++) { + if (FourDArray[ii][jj][kk][ll] != 10) + array2_check[ii] = 10; + } + } + } + } + + for (ii = 0; ii < 10; ii++) + { + array2[ii] = 10; + array2_check[ii] = 10; + } + + for (ii = 0; ii < 10; ii++) + for (jj = 0; jj < 10; jj++) + for (kk = 0; kk < 10; kk++) + for (ll = 0; ll < 10; ll++) + FourDArray[ii][jj][kk][ll] = atoi(argv[1]); + + /* atoi(argv[1]) == 10, so it will convert all 10's to 5's */ + if (FourDArray[0:10:1][0:5:2][9:10:-1][x:y:z] != 10) + array2[:] = 10; + else + array2[:] = 5; + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj < 10; jj += 2) { + for (kk = 9; kk >= 0; kk--) { + for (ll = x; ll < 10; ll = ll += z) { + if (FourDArray[ii][jj][kk][ll] != 10) + array2_check[ii] = 10; + else + array2_check[ii] = 5; + } + } + } + } + + for (ii = 0; ii < 10; ii++) + { + array2[ii] = 10; + array2_check[ii] = 10; + } + + for (ii = 0; ii < 10; ii++) + for (jj = 0; jj < 10; jj++) + for (kk = 0; kk < 10; kk++) + for (ll = 0; ll < 10; ll++) + FourDArray[ii][jj][kk][ll] = atoi(argv[1]); + + /* atoi(argv[1]) == 10, so it will convert all 10's to 5's */ + if (FourDArray[0:10:1][0:5:2][9:10:-1][x:y:z] + + FourDArray[0:10:1][0:5:2][9:-10:1][x:y:z] != 20) + array2[:] = 10; + else + array2[:] = 5; + + for (ii = 0; ii < 10; ii++) { + for (jj = 0; jj < 10; jj += 2) { + for (kk = 9; kk >= 0; kk--) { + for (ll = x; ll < 10; ll = ll += z) { + if (FourDArray[ii][jj][kk][ll] != 10) + array2_check[ii] = 10; + else + array2_check[ii] = 5; + } + } + } + } + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/misc.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/misc.c new file mode 100644 index 00000000000..891e1dc5559 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/misc.c @@ -0,0 +1,112 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main (int argc, char **argv) +{ + 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" } */ + case 1: + x = 5; + break; + case 2: + x = 2; + break; + default: + x = 9; + } + + switch (array2[:][:]) { /* { dg-error "array notations cannot be used as a condition for switch statement" } */ + case 1: + x = 5; + break; + case 2: + x = 2; + break; + default: + x = 9; + } + + switch (array[:] + x) { /* { dg-error "array notations cannot be used as a condition for switch statement" } */ + case 1: + x = 5; + break; + case 2: + x = 2; + break; + default: + x = 9; + } + + switch (array2[:][1:x:4] + x) { /* { dg-error "array notations cannot be used as a condition for switch statement" } */ + case 1: + x = 5; + break; + case 2: + x = 2; + break; + default: + x = 9; + } + + for (ii = 0; ii < array[:]; ii++) /* { dg-error "array notations 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" } */ + { + x = 3; + } + + for (; array2[:][:] < 2;) /* { dg-error "array notations 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" } */ + x = 3; + + while (array[1:1:1]) /* { dg-error "array notations 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" } */ + x = 2; + + do { /* { dg-error "array notations cannot be used as a condition for a do-while statement" } */ + x = 3; + } while (ii != array2[:][:]); + + do { /* { dg-error "array notations cannot be used as a condition for a do-while statement" } */ + x = 2; + } while (ii != (x + array2[:][1:x:2]) + 2); + + do { + x += 3; + if (x == 5) + return array2[:][:]; /* { dg-error "array notation expression cannot be used as a return value" } */ + } while (ii != 0); + + for (ii = 0; ii < 10; ii++) + if (ii % 2) + return array[1:x:ii]; /* { dg-error "array notation expression cannot be used as a return value" } */ + + for (ii = 0; ii < x; ii++) + if (ii) + return array2[:][:]; /* { dg-error "array notation expression cannot be used as a return value" } */ + + for (array[:] = 0; ii < x; ii++) /* This should be OK. */ + x= 2; + + for (ii = 0; ii < 10; array[:]++) /* This is OK. */ + x = 5; + + for (jj = 0; jj < 10; array2[:][:]++) /* This is OK. */ + x = 3; + + for (jj = 0; jj < 10; array2[:][1:x:4]++, jj++) /* This is OK. */ + x = 3; + + return x; +} + diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/n-ptr-test.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/n-ptr-test.c new file mode 100644 index 00000000000..750446c87d2 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/n-ptr-test.c @@ -0,0 +1,48 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#define NUMBER 10 +#include + +int ***func2 (int ***a1, int ***a2, int size) +{ + a1[0:size:1][0:size:1][0:size] += (a2[0:size][0:size][0:size:1] + size); + return a1; +} + +int main (void) +{ + int ii, jj, kk; + int ***array3, ***array2 = NULL, ***array = NULL; + + array = (int ***) malloc (sizeof (int **) * NUMBER); + array2 = (int ***) malloc (sizeof (int **) * NUMBER); + for (ii = 0; ii < NUMBER; ii++) { + array[ii] = (int **) malloc (sizeof (int *) * NUMBER); + array2[ii] = (int **) malloc (sizeof (int *) * NUMBER); + for (jj = 0; jj < NUMBER; jj++) { + array[ii][jj] = (int *) malloc (sizeof (int) * NUMBER); + array2[ii][jj] = (int *) malloc (sizeof (int) * NUMBER); + } + } + + for (ii = 0; ii < NUMBER; ii++) { + for (jj = 0; jj < NUMBER; jj++) { + for (kk = 0; kk < NUMBER; kk++) { + array[ii][jj][kk] = 5; + array2[ii][jj][kk]= 2; + } + } + } + array3 = func2 ((int ***)array, (int ***)array2, NUMBER); + + for (ii = 0; ii < NUMBER; ii++) { + for (jj = 0; jj < NUMBER; jj++) { + for (kk = 0; kk < NUMBER; kk++) { + if (array3[ii][jj][kk] != (7 + NUMBER)) + return 1; + } + } + } + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors.c new file mode 100644 index 00000000000..7b1aa89517f --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main (int argc, char **argv) +{ + int array[10][10], array2[10]; + + array2[:] = array2[: ; /* { dg-error "expected ']'" } */ + + return 0; +} /* { dg-error "expected ';' before" } */ diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors2.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors2.c new file mode 100644 index 00000000000..8bf2282088e --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors2.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main (int argc, char **argv) +{ + int array[10][10], array2[10]; + + array2[:] = array2[1:2:] ; /* { dg-error "expected expression before" } */ + + return 0; /* { dg-error "expected ';' before" } */ +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors3.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors3.c new file mode 100644 index 00000000000..824e18660fd --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors3.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main (int argc, char **argv) +{ + int array[10][10], array2[10]; + + array2[:] = array2[1::] ; /* { dg-error "expected expression before" } */ + + return 0; /* { dg-error "expected ';' before" } */ +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors4.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors4.c new file mode 100644 index 00000000000..25a8a8fb62c --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/parser_errors4.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main (int argc, char **argv) +{ + int array[10][10], array2[10]; + + array2[:] = array2[::] ; /* { dg-error " expected ']' before ':' token" } */ + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch.c new file mode 100644 index 00000000000..a8c9dab5673 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main (int argc, char **argv) +{ + int x = 0; + int array[10][10], array2[10]; + + array[:][:] = array[:]; /* { dg-error "rank mismatch between" } */ + + x = array2[:]; /* { dg-error "cannot be scalar when" } */ + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch2.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch2.c new file mode 100644 index 00000000000..74fece4d172 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch2.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int function_call (int x); +int function_call (int x) +{ + return x; +} + +int main(int argc, char **argv) +{ + int array[100], array2[100][100]; + + array[:] = array[:] + array2[:][:]; /* { dg-error "rank mismatch between" } */ + + if (array[:] + array2[:][:]) /* { dg-error "rank mismatch between" } */ + return argc == 5; + + argc += function_call (array[:] + array2[5:10:2][:]); /* { dg-error "rank mismatch between" } */ + + argc += function_call (function_call (array[:] + array2[5:10:2][:])); /* { dg-error "rank mismatch between" } */ + + argc += __sec_reduce_add (array[:], array2[:][:]); /* { dg-error "rank mismatch between" } */ + + argc += __sec_reduce_add (array2[:][:]) + argc; /* This is OK. */ + return argc; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch3.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch3.c new file mode 100644 index 00000000000..de335922f8a --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/rank_mismatch3.c @@ -0,0 +1,19 @@ +/* { dg-options "-fcilkplus" } */ + +int funct (int x, int y); +void funct_void (int x, int y, int z); +int main(void) +{ + int y, array[100], array2[100], array3[100][100], array4[100]; + + array[:] = ((array2[:] + array[:]) * array4[:]) + array3[:][:]; /* { dg-error "rank mismatch between" } */ + array[:] = funct (array2[:], array3[:][:]); /* { dg-error "rank mismatch between" } */ + array[:] = array3[:][:]; /* { dg-error "rank mismatch between" } */ + array3[:][:] = array[:]; /* { dg-error "rank mismatch between" } */ + array3[:][:] = array[5]; /* This is OK! */ + funct_void (array2[:], array3[:][:], array[:]); /* { dg-error "rank mismatch between" } */ + funct_void (array2[:], array3[:][:], array[:]); /* { dg-error "rank mismatch between" } */ + funct_void (array3[:][:], array2[:], array[:]); /* { dg-error "rank mismatch between" } */ + funct_void (array2[:], array[:], array3[:][0:10:1]); /* { dg-error "rank mismatch between" } */ + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit.c new file mode 100644 index 00000000000..fe66cf87be0 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit.c @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main2 (int argc, char **argv); +int main (int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "5"}; + x = main2 (2, (char **)array); + } + else + x = main2 (argc, argv); + + return x; +} + +int main2 (int argc, char **argv) +{ + int array[10][10], array2[10]; + + array[:][:] = __sec_implicit_index(5) + array[:][:]; /* { dg-error "__sec_implicit_index argument" } */ + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit2.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit2.c new file mode 100644 index 00000000000..29f8c32d4a0 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit2.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main2 (int argc, char **argv); +int main (int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "5"}; + x = main2 (2, (char**)array); + } + else + x = main2 (argc, argv); + + return x; +} + +int main2 (int argc, char **argv) +{ + int array[10][10], array2[10]; + + array[:][:] = __sec_implicit_index(argc) + array[:][:]; /* { dg-error "__sec_implicit_index parameter" } */ + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit_ex.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit_ex.c new file mode 100644 index 00000000000..c5f7cdf18e7 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_implicit_ex.c @@ -0,0 +1,33 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +void abort (void); +void exit (int); + + +int main(int argc, char **argv) +{ + int jj, kk, array_3C[10][10][10]; + int ii,array[10], y = 0, y_int = 0, array2[10], array_3[10][10][10]; + double x, yy, array3[10], array4[10]; + + array[:] = __sec_implicit_index (0); + array_3[:][:][:] = __sec_implicit_index (1) + __sec_implicit_index(0) + + __sec_implicit_index (2); + + for (ii = 0; ii < 10; ii++) + for (jj = 0; jj < 10; jj++) + for (kk = 0; kk < 10; kk++) + array_3C[ii][jj][kk] = ii+jj+kk; + + for (ii = 0; ii < 10; ii++) + for (jj = 0; jj < 10; jj++) + for (kk = 0; kk < 10; kk++) + if (array_3[ii][jj][kk] != array_3C[ii][jj][kk]) + abort (); + + + exit (0); + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_reduce_max_min_ind.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_reduce_max_min_ind.c new file mode 100644 index 00000000000..4bd6030a61d --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_reduce_max_min_ind.c @@ -0,0 +1,32 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus" } */ + +int main2 (int argc, char **argv); +int main (int argc, char **argv) +{ + int x = 0; + if (argc == 1) + { + const char *array[] = {"a.out", "5"}; + x = main2 (2, (char **)array); + } + else + x = main2 (argc, argv); + + return x; +} + +int main2 (int argc, char **argv) +{ + int array[10][10], array2[10]; + int x, y; + x = __sec_reduce_max_ind (array[:][:]); /* { dg-error "cannot have arrays with dimension greater than" } */ + + y = __sec_reduce_max_ind (array2[:]); /* this should be OK. */ + + x = __sec_reduce_min_ind (array[:][:]); /* { dg-error "cannot have arrays with dimension greater than" } */ + + y = __sec_reduce_min_ind (array2[:]); /* this should be OK. */ + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_reduce_return.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_reduce_return.c new file mode 100644 index 00000000000..a72cfafba1c --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/sec_reduce_return.c @@ -0,0 +1,27 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +int add_all (int *my_array, int size) +{ + return __sec_reduce_add (my_array[0:size]); +} + +int mult_all (int *my_array, int size) +{ + return __sec_reduce_mul (my_array[0:size]); +} + +int main (int argc, char **argv) +{ + int array[10000]; + + array[:] = argc; /* All elements should be one. */ + + if (add_all (array, 10000) != 10000) + return 1; + + if (mult_all (array, 10000) != 1) + return 2; + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/side-effects-1.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/side-effects-1.c new file mode 100644 index 00000000000..8b0034e727b --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/side-effects-1.c @@ -0,0 +1,26 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +/* Test that the array index, limit, and stride are evaluated only + once. */ + +int array[1000]; + +int func1_times = 0; +int func2_times = 0; +int func3_times = 0; +int func1() { func1_times++; return 0; } +int func2() { func2_times++; return 0; } +int func3() { func3_times++; return 0; } + +int main() +{ + array[func1() + 11 : func2() + 22 : func3() + 33] = 666; + + if (func1_times != 1 + || func2_times != 1 + || func3_times != 1) + return 1; + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/test_builtin_return.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/test_builtin_return.c new file mode 100644 index 00000000000..0df324a80d4 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/test_builtin_return.c @@ -0,0 +1,71 @@ +/* { dg-options "-lm -fcilkplus" } */ +/* { dg-do run } */ + +#if HAVE_IO +#include +#endif +#include +#define NUMBER 5 + +int func1 (int *a1, int *a2) +{ + return __sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER:1]); +} + +int func2 (int *a1, int *a2) +{ + return (__sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER]) + + __sec_reduce_mul (a1[0:NUMBER] + a2[0:NUMBER])); +} + +int func3 (int *a1, int *a2) +{ + return (int) sqrt ((double)(__sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER]) + + a2[0] + a2[1] + a2[3])); +} + +int func4 (int *a1, int *a2) +{ + return a1[NUMBER-1] * (__sec_reduce_add (a1[0:NUMBER] * a2[0:NUMBER]) + a2[0] + a2[1] + a2[3])/a1[NUMBER-2]; +} +int main(int argc, char **argv) +{ + int array[NUMBER], array2[NUMBER]; + int return_value = 0; + int ii = 0; + for (ii = 0; ii < NUMBER; ii++) + { + array[ii] = argc; /* This should calculate to 1. */ + array2[ii] = argc * argc + argc; /* This should calculate to 2. */ + } + + return_value = func1 (array, array2); +#if HAVE_IO + printf("Return_value = %d\n", return_value); +#endif + if (return_value != (2+2+2+2+2)) + return 1; + + return_value = func2 (array2, array); +#if HAVE_IO + printf("Return_value = %d\n", return_value); +#endif + if (return_value != (3*3*3*3*3) + (2+2+2+2+2)) + return 2; + + return_value = func3 (array, array2); +#if HAVE_IO + printf("Return_value = %d\n", return_value); +#endif + if (return_value != 4) + return 3; + + return_value = func4 (array, array2); +#if HAVE_IO + printf("Return_value = %d\n", return_value); +#endif + if (return_value != 16) + return 4; + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/test_sec_limits.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/test_sec_limits.c new file mode 100644 index 00000000000..f4f3ca5a6bb --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/test_sec_limits.c @@ -0,0 +1,18 @@ +/* { dg-do run } */ +/* { dg-options "-fcilkplus" } */ + +#include +int A[16]; +int a = 0; + +int main () { + if (__sec_reduce_max(A[0:0:2]) != INT_MIN) + a++; + + if (__sec_reduce_min(A[0:0:2]) != INT_MAX) + a++; + + return a; +} + + diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/tst_lngth.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/tst_lngth.c new file mode 100644 index 00000000000..015a7eb7370 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/tst_lngth.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options " -fcilkplus " } */ + +#if HAVE_IO +#include +#endif + +#define N 256 +int A[N], B[N]; + +int +main () +{ + A[0:(N / 4)] = A[4]+ B[0:(N / 2):2]; /* { dg-error "length mismatch between" } */ + A[0:(N / 4)] = B[0:(N / 2):2] + N; /* { dg-error "length mismatch between" } */ + A[0:(N / 4)] = B[0:(N / 2):2] + A[4]; /* { dg-error "length mismatch between" } */ + return 0; +} + diff --git a/gcc/testsuite/c-c++-common/cilk-plus/AN/vla.c b/gcc/testsuite/c-c++-common/cilk-plus/AN/vla.c new file mode 100644 index 00000000000..038ae482df8 --- /dev/null +++ b/gcc/testsuite/c-c++-common/cilk-plus/AN/vla.c @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-options "-fcilkplus -std=c99" } */ + +int func (int x) +{ + return x++; +} +int main(int argc, char **argv) +{ + int array[argc]; + + array[:] = 5; /* { dg-error "start-index and length fields necessary for using array notations in variable-length arrays." } */ + array[0:argc] = 5; /* This is OK. */ + array[0:5:2] = 5; /* This is OK. */ + array[0:argc:2] = 5; /* This is OK. */ + array[0:argc:func (argc-2)] = 5; /* This is OK. */ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/cilk-plus/cilk-plus.exp b/gcc/testsuite/gcc.dg/cilk-plus/cilk-plus.exp new file mode 100644 index 00000000000..59b23056c72 --- /dev/null +++ b/gcc/testsuite/gcc.dg/cilk-plus/cilk-plus.exp @@ -0,0 +1,45 @@ +# Copyright (C) 2013 Free Software Foundation, Inc. + +# This program 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 of the License, or +# (at your option) any later version. +# +# This program 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 +# . + +# Written by Balaji V. Iyer + + +load_lib gcc-dg.exp + +dg-init +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -O0 -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -O1 -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -O2 -ftree-vectorize -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -O3 -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -g -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -g -O0 -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -g -O1 -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -g -O2 -ftree-vectorize -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -g -O3 -fcilkplus" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -O3 -ftree-vectorize -fcilkplus -g" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -O0 -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -O1 -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -O2 -ftree-vectorize -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -O3 -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -g -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -g -O0 -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -g -O1 -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -g -O2 -ftree-vectorize -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -fcilkplus -g -O3 -std=c99" " " +dg-runtest [lsort [glob -nocomplain $srcdir/c-c++-common/cilk-plus/AN/*.c]] " -O3 -ftree-vectorize -std=c99 -g -fcilkplus" " " +dg-finish