@@ -1264,8 +1264,7 @@ extern void protected_set_expr_location
#define OMP_FOR_COND(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 3)
#define OMP_FOR_INCR(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 4)
#define OMP_FOR_PRE_BODY(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 5)
-/* Note that this is only available for OMP_FOR, hence OMP_FOR_CHECK. */
-#define OMP_FOR_ORIG_DECLS(NODE) TREE_OPERAND (OMP_FOR_CHECK (NODE), 6)
+#define OMP_FOR_ORIG_DECLS(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 6)
#define OMP_SECTIONS_BODY(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
#define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
@@ -1101,28 +1101,28 @@ DEFTREECODE (OMP_TASK, "omp_task", tcc_s
DEFTREECODE (OMP_FOR, "omp_for", tcc_statement, 7)
/* OpenMP - #pragma omp simd [clause1 ... clauseN]
- Operands like operands 1-6 of OMP_FOR. */
-DEFTREECODE (OMP_SIMD, "omp_simd", tcc_statement, 6)
+ Operands like for OMP_FOR. */
+DEFTREECODE (OMP_SIMD, "omp_simd", tcc_statement, 7)
/* Cilk Plus - #pragma simd [clause1 ... clauseN]
- Operands like operands 1-6 of OMP_FOR. */
-DEFTREECODE (CILK_SIMD, "cilk_simd", tcc_statement, 6)
+ Operands like for OMP_FOR. */
+DEFTREECODE (CILK_SIMD, "cilk_simd", tcc_statement, 7)
/* Cilk Plus - _Cilk_for (..)
- Operands like operands 1-6 of OMP_FOR. */
-DEFTREECODE (CILK_FOR, "cilk_for", tcc_statement, 6)
+ Operands like for OMP_FOR. */
+DEFTREECODE (CILK_FOR, "cilk_for", tcc_statement, 7)
/* OpenMP - #pragma omp distribute [clause1 ... clauseN]
- Operands like operands 1-6 of OMP_FOR. */
-DEFTREECODE (OMP_DISTRIBUTE, "omp_distribute", tcc_statement, 6)
+ Operands like for OMP_FOR. */
+DEFTREECODE (OMP_DISTRIBUTE, "omp_distribute", tcc_statement, 7)
/* OpenMP - #pragma omp taskloop [clause1 ... clauseN]
- Operands like operands 1-6 of OMP_FOR. */
-DEFTREECODE (OMP_TASKLOOP, "omp_taskloop", tcc_statement, 6)
+ Operands like for OMP_FOR. */
+DEFTREECODE (OMP_TASKLOOP, "omp_taskloop", tcc_statement, 7)
/* OpenMP - #pragma acc loop [clause1 ... clauseN]
- Operands like operands 1-6 of OMP_FOR. */
-DEFTREECODE (OACC_LOOP, "oacc_loop", tcc_statement, 6)
+ Operands like for OMP_FOR. */
+DEFTREECODE (OACC_LOOP, "oacc_loop", tcc_statement, 7)
/* OpenMP - #pragma omp teams [clause1 ... clauseN]
Operand 0: OMP_TEAMS_BODY: Teams body.
@@ -1268,6 +1268,9 @@ extern void c_finish_omp_taskwait (locat
extern void c_finish_omp_taskyield (location_t);
extern tree c_finish_omp_for (location_t, enum tree_code, tree, tree, tree,
tree, tree, tree, tree);
+extern bool c_omp_check_loop_iv (tree, tree, walk_tree_lh);
+extern bool c_omp_check_loop_iv_exprs (location_t, tree, tree, tree, tree,
+ walk_tree_lh);
extern tree c_finish_oacc_wait (location_t, tree, tree);
extern void c_omp_split_clauses (location_t, enum tree_code, omp_clause_mask,
tree, tree *);
@@ -683,14 +683,173 @@ c_finish_omp_for (location_t locus, enum
OMP_FOR_INCR (t) = incrv;
OMP_FOR_BODY (t) = body;
OMP_FOR_PRE_BODY (t) = pre_body;
- if (code == OMP_FOR)
- OMP_FOR_ORIG_DECLS (t) = orig_declv;
+ OMP_FOR_ORIG_DECLS (t) = orig_declv;
SET_EXPR_LOCATION (t, locus);
- return add_stmt (t);
+ return t;
}
}
+/* Type for passing data in between c_omp_check_loop_iv and
+ c_omp_check_loop_iv_r. */
+
+struct c_omp_check_loop_iv_data
+{
+ tree declv;
+ bool fail;
+ location_t stmt_loc;
+ location_t expr_loc;
+ int kind;
+ walk_tree_lh lh;
+ hash_set<tree> *ppset;
+};
+
+/* Helper function called via walk_tree, to diagnose uses
+ of associated loop IVs inside of lb, b and incr expressions
+ of OpenMP loops. */
+
+static tree
+c_omp_check_loop_iv_r (tree *tp, int *walk_subtrees, void *data)
+{
+ struct c_omp_check_loop_iv_data *d
+ = (struct c_omp_check_loop_iv_data *) data;
+ if (DECL_P (*tp))
+ {
+ int i;
+ for (i = 0; i < TREE_VEC_LENGTH (d->declv); i++)
+ if (*tp == TREE_VEC_ELT (d->declv, i))
+ {
+ location_t loc = d->expr_loc;
+ if (loc == UNKNOWN_LOCATION)
+ loc = d->stmt_loc;
+ switch (d->kind)
+ {
+ case 0:
+ error_at (loc, "initializer expression refers to "
+ "iteration variable %qD", *tp);
+ break;
+ case 1:
+ error_at (loc, "condition expression refers to "
+ "iteration variable %qD", *tp);
+ break;
+ case 2:
+ error_at (loc, "increment expression refers to "
+ "iteration variable %qD", *tp);
+ break;
+ }
+ d->fail = true;
+ }
+ }
+ /* Don't walk dtors added by C++ wrap_cleanups_r. */
+ else if (TREE_CODE (*tp) == TRY_CATCH_EXPR
+ && TRY_CATCH_IS_CLEANUP (*tp))
+ {
+ *walk_subtrees = 0;
+ return walk_tree_1 (&TREE_OPERAND (*tp, 0), c_omp_check_loop_iv_r, data,
+ d->ppset, d->lh);
+ }
+
+ return NULL_TREE;
+}
+
+/* Diagnose invalid references to loop iterators in lb, b and incr
+ expressions. */
+
+bool
+c_omp_check_loop_iv (tree stmt, tree declv, walk_tree_lh lh)
+{
+ hash_set<tree> pset;
+ struct c_omp_check_loop_iv_data data;
+ int i;
+
+ data.declv = declv;
+ data.fail = false;
+ data.stmt_loc = EXPR_LOCATION (stmt);
+ data.lh = lh;
+ data.ppset = &pset;
+ for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (stmt)); i++)
+ {
+ tree init = TREE_VEC_ELT (OMP_FOR_INIT (stmt), i);
+ gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
+ tree decl = TREE_OPERAND (init, 0);
+ tree cond = TREE_VEC_ELT (OMP_FOR_COND (stmt), i);
+ gcc_assert (COMPARISON_CLASS_P (cond));
+ gcc_assert (TREE_OPERAND (cond, 0) == decl);
+ tree incr = TREE_VEC_ELT (OMP_FOR_INCR (stmt), i);
+ data.expr_loc = EXPR_LOCATION (TREE_OPERAND (init, 1));
+ data.kind = 0;
+ walk_tree_1 (&TREE_OPERAND (init, 1),
+ c_omp_check_loop_iv_r, &data, &pset, lh);
+ /* Don't warn for C++ random access iterators here, the
+ expression then involves the subtraction and always refers
+ to the original value. The C++ FE needs to warn on those
+ earlier. */
+ if (decl == TREE_VEC_ELT (declv, i))
+ {
+ data.expr_loc = EXPR_LOCATION (cond);
+ data.kind = 1;
+ walk_tree_1 (&TREE_OPERAND (cond, 1),
+ c_omp_check_loop_iv_r, &data, &pset, lh);
+ }
+ if (TREE_CODE (incr) == MODIFY_EXPR)
+ {
+ gcc_assert (TREE_OPERAND (incr, 0) == decl);
+ incr = TREE_OPERAND (incr, 1);
+ data.kind = 2;
+ if (TREE_CODE (incr) == PLUS_EXPR
+ && TREE_OPERAND (incr, 1) == decl)
+ {
+ data.expr_loc = EXPR_LOCATION (TREE_OPERAND (incr, 0));
+ walk_tree_1 (&TREE_OPERAND (incr, 0),
+ c_omp_check_loop_iv_r, &data, &pset, lh);
+ }
+ else
+ {
+ data.expr_loc = EXPR_LOCATION (TREE_OPERAND (incr, 1));
+ walk_tree_1 (&TREE_OPERAND (incr, 1),
+ c_omp_check_loop_iv_r, &data, &pset, lh);
+ }
+ }
+ }
+ return !data.fail;
+}
+
+/* Similar, but allows to check the init or cond expressions individually. */
+
+bool
+c_omp_check_loop_iv_exprs (location_t stmt_loc, tree declv, tree decl,
+ tree init, tree cond, walk_tree_lh lh)
+{
+ hash_set<tree> pset;
+ struct c_omp_check_loop_iv_data data;
+
+ data.declv = declv;
+ data.fail = false;
+ data.stmt_loc = stmt_loc;
+ data.lh = lh;
+ data.ppset = &pset;
+ if (init)
+ {
+ data.expr_loc = EXPR_LOCATION (init);
+ data.kind = 0;
+ walk_tree_1 (&init,
+ c_omp_check_loop_iv_r, &data, &pset, lh);
+ }
+ if (cond)
+ {
+ gcc_assert (COMPARISON_CLASS_P (cond));
+ data.expr_loc = EXPR_LOCATION (init);
+ data.kind = 1;
+ if (TREE_OPERAND (cond, 0) == decl)
+ walk_tree_1 (&TREE_OPERAND (cond, 1),
+ c_omp_check_loop_iv_r, &data, &pset, lh);
+ else
+ walk_tree_1 (&TREE_OPERAND (cond, 0),
+ c_omp_check_loop_iv_r, &data, &pset, lh);
+ }
+ return !data.fail;
+}
+
/* Right now we have 21 different combined/composite constructs, this
function attempts to split or duplicate clauses for combined
constructs. CODE is the innermost construct in the combined construct,
@@ -13991,8 +13991,15 @@ c_parser_omp_for_loop (location_t loc, c
{
stmt = c_finish_omp_for (loc, code, declv, NULL, initv, condv,
incrv, body, pre_body);
+
+ /* Check for iterators appearing in lb, b or incr expressions. */
+ if (stmt && !c_omp_check_loop_iv (stmt, declv, NULL))
+ stmt = NULL_TREE;
+
if (stmt)
{
+ add_stmt (stmt);
+
if (cclauses != NULL
&& cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] != NULL)
{
@@ -6326,7 +6326,7 @@ extern tree begin_omp_task (void);
extern tree finish_omp_task (tree, tree);
extern tree finish_omp_for (location_t, enum tree_code,
tree, tree, tree, tree, tree,
- tree, tree, tree);
+ tree, tree, vec<tree> *, tree);
extern void finish_omp_atomic (enum tree_code, enum tree_code,
tree, tree, tree, tree, tree,
bool);
@@ -32447,6 +32447,7 @@ cp_parser_omp_for_loop_init (cp_parser *
tree &this_pre_body,
vec<tree, va_gc> *for_block,
tree &init,
+ tree &orig_init,
tree &decl,
tree &real_decl)
{
@@ -32544,6 +32545,7 @@ cp_parser_omp_for_loop_init (cp_parser *
cp_finish_decl (decl, init, !is_non_constant_init,
asm_specification,
LOOKUP_ONLYCONVERTING);
+ orig_init = init;
if (CLASS_TYPE_P (TREE_TYPE (decl)))
{
vec_safe_push (for_block, this_pre_body);
@@ -32621,6 +32623,7 @@ cp_parser_omp_for_loop_init (cp_parser *
cp_parser_parse_definitely (parser);
cp_parser_require (parser, CPP_EQ, RT_EQ);
rhs = cp_parser_assignment_expression (parser);
+ orig_init = rhs;
finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs),
decl, NOP_EXPR,
rhs,
@@ -32650,13 +32653,14 @@ static tree
cp_parser_omp_for_loop (cp_parser *parser, enum tree_code code, tree clauses,
tree *cclauses)
{
- tree init, cond, incr, body, decl, pre_body = NULL_TREE, ret;
+ tree init, orig_init, cond, incr, body, decl, pre_body = NULL_TREE, ret;
tree real_decl, initv, condv, incrv, declv;
tree this_pre_body, cl, ordered_cl = NULL_TREE;
location_t loc_first;
bool collapse_err = false;
int i, collapse = 1, ordered = 0, count, nbraces = 0;
vec<tree, va_gc> *for_block = make_tree_vector ();
+ auto_vec<tree, 4> orig_inits;
for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
@@ -32723,13 +32727,13 @@ cp_parser_omp_for_loop (cp_parser *parse
if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
return NULL;
- init = decl = real_decl = NULL;
+ init = orig_init = decl = real_decl = NULL;
this_pre_body = push_stmt_list ();
add_private_clause
= cp_parser_omp_for_loop_init (parser, code,
this_pre_body, for_block,
- init, decl, real_decl);
+ init, orig_init, decl, real_decl);
cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
if (this_pre_body)
@@ -32861,6 +32865,11 @@ cp_parser_omp_for_loop (cp_parser *parse
TREE_VEC_ELT (initv, i) = init;
TREE_VEC_ELT (condv, i) = cond;
TREE_VEC_ELT (incrv, i) = incr;
+ if (orig_init)
+ {
+ orig_inits.safe_grow_cleared (i + 1);
+ orig_inits[i] = orig_init;
+ }
if (i == count - 1)
break;
@@ -32918,7 +32927,7 @@ cp_parser_omp_for_loop (cp_parser *parse
ret = NULL_TREE;
else
ret = finish_omp_for (loc_first, code, declv, NULL, initv, condv, incrv,
- body, pre_body, clauses);
+ body, pre_body, &orig_inits, clauses);
while (nbraces)
{
@@ -15237,7 +15237,7 @@ tsubst_expr (tree t, tree args, tsubst_f
if (OMP_FOR_INIT (t) != NULL_TREE)
{
declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
- if (TREE_CODE (t) == OMP_FOR && OMP_FOR_ORIG_DECLS (t))
+ if (OMP_FOR_ORIG_DECLS (t))
orig_declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
@@ -15264,7 +15264,7 @@ tsubst_expr (tree t, tree args, tsubst_f
if (OMP_FOR_INIT (t) != NULL_TREE)
t = finish_omp_for (EXPR_LOCATION (t), TREE_CODE (t), declv,
orig_declv, initv, condv, incrv, body, pre_body,
- clauses);
+ NULL, clauses);
else
{
t = make_node (TREE_CODE (t));
@@ -7286,9 +7286,10 @@ finish_omp_task (tree clauses, tree body
static bool
handle_omp_for_class_iterator (int i, location_t locus, enum tree_code code,
- tree declv, tree initv, tree condv, tree incrv,
- tree *body, tree *pre_body, tree &clauses,
- tree *lastp, int collapse, int ordered)
+ tree declv, tree orig_declv, tree initv,
+ tree condv, tree incrv, tree *body,
+ tree *pre_body, tree &clauses, tree *lastp,
+ int collapse, int ordered)
{
tree diff, iter_init, iter_incr = NULL, last;
tree incr_var = NULL, orig_pre_body, orig_body, c;
@@ -7345,6 +7346,10 @@ handle_omp_for_class_iterator (int i, lo
TREE_OPERAND (cond, 1), iter);
return true;
}
+ if (!c_omp_check_loop_iv_exprs (locus, orig_declv,
+ TREE_VEC_ELT (declv, i), NULL_TREE,
+ cond, cp_walk_subtrees))
+ return true;
switch (TREE_CODE (incr))
{
@@ -7600,7 +7605,7 @@ handle_omp_for_class_iterator (int i, lo
tree
finish_omp_for (location_t locus, enum tree_code code, tree declv,
tree orig_declv, tree initv, tree condv, tree incrv,
- tree body, tree pre_body, tree clauses)
+ tree body, tree pre_body, vec<tree> *orig_inits, tree clauses)
{
tree omp_for = NULL, orig_incr = NULL;
tree decl = NULL, init, cond, incr, orig_decl = NULL_TREE, block = NULL_TREE;
@@ -7676,6 +7681,20 @@ finish_omp_for (location_t locus, enum t
TREE_VEC_ELT (initv, i) = init;
}
+ if (orig_inits)
+ {
+ bool fail = false;
+ tree orig_init;
+ FOR_EACH_VEC_ELT (*orig_inits, i, orig_init)
+ if (orig_init
+ && !c_omp_check_loop_iv_exprs (locus, declv,
+ TREE_VEC_ELT (declv, i), orig_init,
+ NULL_TREE, cp_walk_subtrees))
+ fail = true;
+ if (fail)
+ return NULL;
+ }
+
if (dependent_omp_for_p (declv, initv, condv, incrv))
{
tree stmt;
@@ -7749,10 +7768,10 @@ finish_omp_for (location_t locus, enum t
}
if (code == CILK_FOR && i == 0)
orig_decl = decl;
- if (handle_omp_for_class_iterator (i, locus, code, declv, initv,
- condv, incrv, &body, &pre_body,
- clauses, &last, collapse,
- ordered))
+ if (handle_omp_for_class_iterator (i, locus, code, declv, orig_declv,
+ initv, condv, incrv, &body,
+ &pre_body, clauses, &last,
+ collapse, ordered))
return NULL;
continue;
}
@@ -7811,6 +7830,10 @@ finish_omp_for (location_t locus, enum t
omp_for = c_finish_omp_for (locus, code, declv, orig_declv, initv, condv,
incrv, body, pre_body);
+ /* Check for iterators appearing in lb, b or incr expressions. */
+ if (omp_for && !c_omp_check_loop_iv (omp_for, orig_declv, cp_walk_subtrees))
+ omp_for = NULL_TREE;
+
if (omp_for == NULL)
{
if (block)
@@ -7818,6 +7841,8 @@ finish_omp_for (location_t locus, enum t
return NULL;
}
+ add_stmt (omp_for);
+
for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for)); i++)
{
decl = TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for), i), 0);
@@ -7,14 +7,14 @@ foo (int x)
{
int i = 0;
#pragma omp parallel for simd
- for (i = (i & x); i < 10; i = i + 2)
+ for (i = (i & x); i < 10; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
;
i = 0;
#pragma omp parallel for simd
- for (i = 0; i < (i & x) + 10; i = i + 2)
+ for (i = 0; i < (i & x) + 10; i = i + 2) /* { dg-error "condition expression refers to iteration variable" } */
;
i = 0;
#pragma omp parallel for simd
- for (i = 0; i < 10; i = i + ((i & x) + 2))
+ for (i = 0; i < 10; i = i + ((i & x) + 2)) /* { dg-error "increment expression refers to iteration variable" } */
;
}
@@ -0,0 +1,283 @@
+int bar (int);
+int baz (int *);
+
+void
+f1 (int x)
+{
+ int i = 0, j = 0;
+ #pragma omp for
+ for (i = 0; i < 16; i++)
+ ;
+ #pragma omp for
+ for (i = 0; 16 > i; i++)
+ ;
+ #pragma omp for
+ for (i = 0; i < 16; i = i + 2)
+ ;
+ #pragma omp for
+ for (i = 0; i < 16; i = 2 + i)
+ ;
+ #pragma omp for /* { dg-error "initializer expression refers to iteration variable" } */
+ for (i = i; i < 16; i++)
+ ;
+ #pragma omp for
+ for (i = 2 * (i & x); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = bar (i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = baz (&i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 2 * i + 17; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; 2 * i + 17 > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; bar (i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for /* { dg-error "increment expression refers to iteration variable" } */
+ for (i = 5; i < 16; i += i)
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + 2 * i) /* { dg-error "invalid increment expression|increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for /* { dg-error "increment expression refers to iteration variable" } */
+ for (i = 5; i < 16; i = i + i)
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = baz (&i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2)
+ for (j = 0; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (i = j; i < 16; i = i + 2)
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (i = 0; i < 16; i = i + 2)
+ for (j = i; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2)
+ for (j = i + 3; j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = baz (&i); j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = 16; j > (i & x); j--) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < i; j++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < i + 4; j++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < j + 4; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < j; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < bar (j); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < baz (&i); j++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2) /* { dg-error "increment expression refers to iteration variable" } */
+ for (i = 0; i < 16; i += j)
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2) /* { dg-error "increment expression refers to iteration variable" } */
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < 16; j += i)
+ ;
+ #pragma omp for collapse(2) /* { dg-error "increment expression refers to iteration variable" } */
+ for (i = 0; i < 16; i = j + i)
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2) /* { dg-error "increment expression refers to iteration variable" } */
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < 16; j = j + i)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = bar (j) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < 16; j = j + baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+void
+f2 (int x)
+{
+ #pragma omp for
+ for (int i = 0; i < 16; i++)
+ ;
+ #pragma omp for
+ for (int i = 0; 16 > i; i++)
+ ;
+ #pragma omp for
+ for (int i = 0; i < 16; i = i + 2)
+ ;
+ #pragma omp for
+ for (int i = 0; i < 16; i = 2 + i)
+ ;
+ #pragma omp for /* { dg-error "initializer expression refers to iteration variable" } */
+ for (int i = i; i < 16; i++)
+ ;
+ #pragma omp for
+ for (int i = 2 * (i & x); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = bar (i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = baz (&i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 2 * i + 17; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; 2 * i + 17 > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; bar (i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for /* { dg-error "increment expression refers to iteration variable" } */
+ for (int i = 5; i < 16; i += i)
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + 2 * i) /* { dg-error "invalid increment expression|increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for /* { dg-error "increment expression refers to iteration variable" } */
+ for (int i = 5; i < 16; i = i + i)
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = baz (&i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2)
+ for (int j = 0; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (int i = 0; i < 16; i = i + 2)
+ for (int j = i; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2)
+ for (int j = i + 3; j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = baz (&i); j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = 16; j > (i & x); j--) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < i; j++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < i + 4; j++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < baz (&i); j++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2) /* { dg-error "increment expression refers to iteration variable" } */
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < 16; j += i)
+ ;
+ #pragma omp for collapse(2) /* { dg-error "increment expression refers to iteration variable" } */
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < 16; j = j + i)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < 16; j = j + baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+void
+f3 (void)
+{
+ int j = 0;
+ #pragma omp for collapse(2)
+ for (int i = j; i < 16; i = i + 2)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < j + 4; i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < j; i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < bar (j); i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i += j)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = j + i)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = bar (j) + i)
+ for (int j = 0; j < 16; j++)
+ ;
+}
@@ -6,12 +6,12 @@ template<int> void
foo ()
{
#pragma omp parallel for
- for (auto i = i = 0; i<4; ++i) // { dg-error "incomplete|unable|invalid|auto" }
+ for (auto i = i = 0; i<4; ++i) // { dg-error "initializer expression refers to iteration variable" }
;
}
void
bar ()
{
- foo<0> (); // { dg-message "required from here" }
+ foo<0> ();
}
@@ -0,0 +1,283 @@
+int bar (int);
+int baz (int *);
+
+void
+f1 (int x)
+{
+ int i = 0, j = 0;
+ #pragma omp for
+ for (i = 0; i < 16; i++)
+ ;
+ #pragma omp for
+ for (i = 0; 16 > i; i++)
+ ;
+ #pragma omp for
+ for (i = 0; i < 16; i = i + 2)
+ ;
+ #pragma omp for
+ for (i = 0; i < 16; i = 2 + i)
+ ;
+ #pragma omp for
+ for (i = i; i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 2 * (i & x); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = bar (i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = baz (&i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 2 * i + 17; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; 2 * i + 17 > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; bar (i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + 2 * i) /* { dg-error "invalid increment expression|increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = baz (&i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2)
+ for (j = 0; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = j; i < 16; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (j = i; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2)
+ for (j = i + 3; j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (j = baz (&i); j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 16; j > (i & x); j--)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < i; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < i + 4; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < j + 4; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < j; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < bar (j); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < baz (&i); j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i += j) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j += i)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = j + i) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j = j + i)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = bar (j) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < 16; j = j + baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+void
+f2 (int x)
+{
+ #pragma omp for
+ for (int i = 0; i < 16; i++)
+ ;
+ #pragma omp for
+ for (int i = 0; 16 > i; i++)
+ ;
+ #pragma omp for
+ for (int i = 0; i < 16; i = i + 2)
+ ;
+ #pragma omp for
+ for (int i = 0; i < 16; i = 2 + i)
+ ;
+ #pragma omp for
+ for (int i = i; i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 2 * (i & x); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = bar (i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = baz (&i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 2 * i + 17; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; 2 * i + 17 > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; bar (i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + 2 * i) /* { dg-error "invalid increment expression|increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = baz (&i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2)
+ for (int j = 0; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (int j = i; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2)
+ for (int j = i + 3; j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (int j = baz (&i); j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 16; j > (i & x); j--)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 0; j < i; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 0; j < i + 4; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 0; j < baz (&i); j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (int j = 0; j < 16; j += i)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (int j = 0; j < 16; j = j + i)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < 16; j = j + baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+void
+f3 (void)
+{
+ int j = 0;
+ #pragma omp for collapse(2)
+ for (int i = j; i < 16; i = i + 2)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < j + 4; i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < j; i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < bar (j); i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i += j)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = j + i)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = bar (j) + i)
+ for (int j = 0; j < 16; j++)
+ ;
+}
@@ -0,0 +1,294 @@
+int bar (int);
+int baz (int *);
+
+template <int N>
+void
+f1 (int x)
+{
+ int i = 0, j = 0;
+ #pragma omp for
+ for (i = 0; i < 16; i++)
+ ;
+ #pragma omp for
+ for (i = 0; 16 > i; i++)
+ ;
+ #pragma omp for
+ for (i = 0; i < 16; i = i + 2)
+ ;
+ #pragma omp for
+ for (i = 0; i < 16; i = 2 + i)
+ ;
+ #pragma omp for
+ for (i = i; i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 2 * (i & x); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = bar (i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = baz (&i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 2 * i + 17; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; 2 * i + 17 > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; bar (i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + 2 * i) /* { dg-error "invalid increment expression|increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = i + bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i = baz (&i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = 5; i < 16; i += baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2)
+ for (j = 0; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = j; i < 16; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (j = i; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = i + 2)
+ for (j = i + 3; j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = baz (&i); j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 16; j > (i & x); j--)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < i; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < i + 4; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < j + 4; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < j; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < bar (j); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = 0; j < baz (&i); j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i += j) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j += i)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = j + i) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j = j + i)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i = bar (j) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = 0; i < 16; i++)
+ for (j = 0; j < 16; j = j + baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+template <int N>
+void
+f2 (int x)
+{
+ #pragma omp for
+ for (int i = 0; i < 16; i++)
+ ;
+ #pragma omp for
+ for (int i = 0; 16 > i; i++)
+ ;
+ #pragma omp for
+ for (int i = 0; i < 16; i = i + 2)
+ ;
+ #pragma omp for
+ for (int i = 0; i < 16; i = 2 + i)
+ ;
+ #pragma omp for
+ for (int i = i; i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 2 * (i & x); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = bar (i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = baz (&i); i < 16; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 2 * i + 17; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; 2 * i + 17 > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; bar (i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + 2 * i) /* { dg-error "invalid increment expression|increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = i + bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i = baz (&i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += bar (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (int i = 5; i < 16; i += baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2)
+ for (int j = 0; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (int j = i; j < 16; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = i + 2)
+ for (int j = i + 3; j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = baz (&i); j < 16; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 16; j > (i & x); j--)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 0; j < i; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 0; j < i + 4; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (int j = 0; j < baz (&i); j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (int j = 0; j < 16; j += i)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++) /* { dg-error "increment expression refers to iteration variable" } */
+ for (int j = 0; j < 16; j = j + i)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i++)
+ for (int j = 0; j < 16; j = j + baz (&i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+template <int N>
+void
+f3 ()
+{
+ int j = 0;
+ #pragma omp for collapse(2)
+ for (int i = j; i < 16; i = i + 2)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < j + 4; i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < j; i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < bar (j); i++)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i += j)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = j + i)
+ for (int j = 0; j < 16; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (int i = 0; i < 16; i = bar (j) + i)
+ for (int j = 0; j < 16; j++)
+ ;
+}
+
+void
+foo ()
+{
+ f1 <0> (0);
+ f2 <0> (0);
+ f3 <0> ();
+}
@@ -0,0 +1,306 @@
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+
+template <typename T>
+class I
+{
+public:
+ typedef ptrdiff_t difference_type;
+ I ();
+ ~I ();
+ I (T *);
+ I (const I &);
+ T &operator * ();
+ T *operator -> ();
+ T &operator [] (const difference_type &) const;
+ I &operator = (const I &);
+ I &operator ++ ();
+ I operator ++ (int);
+ I &operator -- ();
+ I operator -- (int);
+ I &operator += (const difference_type &);
+ I &operator -= (const difference_type &);
+ I operator + (const difference_type &) const;
+ I operator - (const difference_type &) const;
+ template <typename S> friend bool operator == (I<S> &, I<S> &);
+ template <typename S> friend bool operator == (const I<S> &, const I<S> &);
+ template <typename S> friend bool operator < (I<S> &, I<S> &);
+ template <typename S> friend bool operator < (const I<S> &, const I<S> &);
+ template <typename S> friend bool operator <= (I<S> &, I<S> &);
+ template <typename S> friend bool operator <= (const I<S> &, const I<S> &);
+ template <typename S> friend bool operator > (I<S> &, I<S> &);
+ template <typename S> friend bool operator > (const I<S> &, const I<S> &);
+ template <typename S> friend bool operator >= (I<S> &, I<S> &);
+ template <typename S> friend bool operator >= (const I<S> &, const I<S> &);
+ template <typename S> friend typename I<S>::difference_type operator - (I<S> &, I<S> &);
+ template <typename S> friend typename I<S>::difference_type operator - (const I<S> &, const I<S> &);
+ template <typename S> friend I<S> operator + (typename I<S>::difference_type , const I<S> &);
+private:
+ T *p;
+};
+
+template <typename T> bool operator == (I<T> &, I<T> &);
+template <typename T> bool operator == (const I<T> &, const I<T> &);
+template <typename T> bool operator != (I<T> &, I<T> &);
+template <typename T> bool operator != (const I<T> &, const I<T> &);
+template <typename T> bool operator < (I<T> &, I<T> &);
+template <typename T> bool operator < (const I<T> &, const I<T> &);
+template <typename T> bool operator <= (I<T> &, I<T> &);
+template <typename T> bool operator <= (const I<T> &, const I<T> &);
+template <typename T> bool operator > (I<T> &, I<T> &);
+template <typename T> bool operator > (const I<T> &, const I<T> &);
+template <typename T> bool operator >= (I<T> &, I<T> &);
+template <typename T> bool operator >= (const I<T> &, const I<T> &);
+template <typename T> typename I<T>::difference_type operator - (I<T> &, I<T> &);
+template <typename T> typename I<T>::difference_type operator - (const I<T> &, const I<T> &);
+template <typename T> I<T> operator + (typename I<T>::difference_type, const I<T> &);
+
+ptrdiff_t foo (I<int> &);
+I<int> &bar (I<int> &);
+I<int> &baz (I<int> *);
+
+void
+f1 (I<int> &x, I<int> &y, I<int> &u, I<int> &v)
+{
+ I<int> i, j;
+ #pragma omp for
+ for (i = x; i < y; i++)
+ ;
+ #pragma omp for
+ for (i = x; y > i; i++)
+ ;
+ #pragma omp for
+ for (i = x; i < y; i = i + 2)
+ ;
+ #pragma omp for
+ for (i = x; i < y; i = 2 + i)
+ ;
+ #pragma omp for
+ for (i = i; i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = i + 3; i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = bar (i); i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = baz (&i); i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = x; i <= i + 5; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = x; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = x; baz (&i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = x; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = x; i < y; i += foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = x; i < y; i = i + foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (i = x; i < y; i = foo (i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i = i + 2)
+ for (j = u; j < y; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = j; i < y; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (j = x; j < y; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (j = i; j < v; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i = i + 2)
+ for (j = i + 3; j < v; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++)
+ for (j = baz (&i); j < v; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = v; j > i; j--)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = x; j < i; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = u; j < i + 4; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < j + 4; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < j; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < bar (j); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (j = u; j < baz (&i); j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i += foo (j)) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++)
+ for (j = u; j < v; j += foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i = foo (j) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++)
+ for (j = u; j < y; j = j + (i - v)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i = foo (j) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ for (j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (i = x; i < y; i++)
+ for (j = u; j < v; j = j + foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+void
+f2 (I<int> &x, I<int> &y, I<int> &u, I<int> &v)
+{
+ #pragma omp for
+ for (I<int> i = x; i < y; i++)
+ ;
+ #pragma omp for
+ for (I<int> i = x; y > i; i++)
+ ;
+ #pragma omp for
+ for (I<int> i = x; i < y; i = i + 2)
+ ;
+ #pragma omp for
+ for (I<int> i = x; i < y; i = 2 + i)
+ ;
+ #pragma omp for
+ for (I<int> i = i; i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = i + 3; i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = bar (i); i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = baz (&i); i < y; i++) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = x; i <= i + 5; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = x; i <= baz (&i); i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = x; baz (&i) > i; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = x; i <= i; i++) /* { dg-error "invalid controlling predicate|condition expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = x; i < y; i += foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = x; i < y; i = i + foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for
+ for (I<int> i = x; i < y; i = foo (i) + i) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i = i + 2)
+ for (I<int> j = u; j < y; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i = i + 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ for (I<int> j = i; j < v; j += 2)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i = i + 2)
+ for (I<int> j = i + 3; j < v; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++)
+ for (I<int> j = baz (&i); j < v; j += 2) /* { dg-error "initializer expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (I<int> j = v; j > i; j--)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (I<int> j = x; j < i; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (I<int> j = u; j < i + 4; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++) /* { dg-error "condition expression refers to iteration variable" } */
+ for (I<int> j = u; j < baz (&i); j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++)
+ for (I<int> j = u; j < v; j += foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++)
+ for (I<int> j = u; j < y; j = j + (i - v)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i++)
+ for (I<int> j = u; j < v; j = j + foo (i)) /* { dg-error "increment expression refers to iteration variable" } */
+ ;
+}
+
+void
+f3 (I<int> &x, I<int> &y, I<int> &u, I<int> &v)
+{
+ I<int> j;
+ #pragma omp for collapse(2)
+ for (I<int> i = j; i < y; i = i + 2)
+ for (I<int> j = x; j < y; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < j + 4; i++)
+ for (I<int> j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < j; i++)
+ for (I<int> j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < bar (j); i++)
+ for (I<int> j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i += foo (j))
+ for (I<int> j = u; j < v; j++)
+ ;
+ #pragma omp for collapse(2)
+ for (I<int> i = x; i < y; i = foo (j) + i)
+ for (I<int> j = u; j < v; j++)
+ ;
+}