+2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
+
+ * gimplify.cc (gimplify_omp_affinity): Use macros for accessing
+ iterator elements.
+ (compute_omp_iterator_count): Likewise.
+ (build_omp_iterator_loop): Likewise.
+ (remove_unused_omp_iterator_vars): Likewise.
+ (build_omp_iterators_loops): Likewise.
+ (enter_omp_iterator_loop_context_1): Likewise.
+ (extract_base_bit_offset): Likewise.
+ * omp-low.cc (lower_omp_map_iterator_expr): Likewise.
+ (lower_omp_map_iterator_size): Likewise.
+ (allocate_omp_iterator_elems): Likewise.
+ (free_omp_iterator_elems): Likewise.
+ * tree-inline.cc (copy_tree_body_r): Likewise.
+ * tree-pretty-print.cc (dump_omp_iterators): Likewise.
+ * tree.h (OMP_ITERATORS_VAR, OMP_ITERATORS_BEGIN, OMP_ITERATORS_END,
+ OMP_ITERATORS_STEP, OMP_ITERATORS_ORIG_STEP, OMP_ITERATORS_BLOCK,
+ OMP_ITERATORS_LABEL, OMP_ITERATORS_INDEX, OMP_ITERATORS_ELEMS,
+ OMP_ITERATORS_COUNT, OMP_ITERATORS_EXPANDED_P): New macros.
+
2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
* gimplify.cc (omp_iterator_elems_length): New.
+2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
+
+ * c-parser.cc (c_parser_omp_iterators): Use macros for accessing
+ iterator elements.
+ (c_parser_omp_clause_affinity): Likewise.
+ (c_parser_omp_clause_depend): Likewise.
+ (c_parser_omp_clause_map): Likewise.
+ (c_parser_omp_clause_from_to): Likewise.
+ * c-typeck.cc (c_omp_finish_iterators): Likewise.
+
2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
* c-typeck.cc (handle_omp_array_sections): Add extra argument. Set
pushdecl (iter_var);
*last = make_tree_vec (6);
- TREE_VEC_ELT (*last, 0) = iter_var;
- TREE_VEC_ELT (*last, 1) = begin;
- TREE_VEC_ELT (*last, 2) = end;
- TREE_VEC_ELT (*last, 3) = step;
+ OMP_ITERATORS_VAR (*last) = iter_var;
+ OMP_ITERATORS_BEGIN (*last) = begin;
+ OMP_ITERATORS_END (*last) = end;
+ OMP_ITERATORS_STEP (*last) = step;
last = &TREE_CHAIN (*last);
if (c_parser_next_token_is (parser, CPP_COMMA))
tree block = pop_scope ();
if (iterators != error_mark_node)
{
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
for (tree c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
OMP_CLAUSE_DECL (c) = build_tree_list (iterators,
OMP_CLAUSE_DECL (c));
if (iterators == error_mark_node)
iterators = NULL_TREE;
else
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
}
for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
if (iterators == error_mark_node)
iterators = NULL_TREE;
else
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
}
for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
if (iterators == error_mark_node)
iterators = NULL_TREE;
else
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
}
if (iterators)
bool ret = false;
for (tree it = iter; it; it = TREE_CHAIN (it))
{
- tree var = TREE_VEC_ELT (it, 0);
- tree begin = TREE_VEC_ELT (it, 1);
- tree end = TREE_VEC_ELT (it, 2);
- tree step = TREE_VEC_ELT (it, 3);
+ tree var = OMP_ITERATORS_VAR (it);
+ tree begin = OMP_ITERATORS_BEGIN (it);
+ tree end = OMP_ITERATORS_END (it);
+ tree step = OMP_ITERATORS_STEP (it);
tree orig_step;
tree type = TREE_TYPE (var);
location_t loc = DECL_SOURCE_LOCATION (var);
tree it2;
for (it2 = TREE_CHAIN (it); it2; it2 = TREE_CHAIN (it2))
{
- tree var2 = TREE_VEC_ELT (it2, 0);
- tree begin2 = TREE_VEC_ELT (it2, 1);
- tree end2 = TREE_VEC_ELT (it2, 2);
- tree step2 = TREE_VEC_ELT (it2, 3);
+ tree var2 = OMP_ITERATORS_VAR (it2);
+ tree begin2 = OMP_ITERATORS_BEGIN (it2);
+ tree end2 = OMP_ITERATORS_END (it2);
+ tree step2 = OMP_ITERATORS_STEP (it2);
tree type2 = TREE_TYPE (var2);
location_t loc2 = DECL_SOURCE_LOCATION (var2);
struct c_find_omp_var_s data = { var, &pset };
ret = true;
continue;
}
- TREE_VEC_ELT (it, 1) = begin;
- TREE_VEC_ELT (it, 2) = end;
- TREE_VEC_ELT (it, 3) = step;
- TREE_VEC_ELT (it, 4) = orig_step;
+ OMP_ITERATORS_BEGIN (it) = begin;
+ OMP_ITERATORS_END (it) = end;
+ OMP_ITERATORS_STEP (it) = step;
+ OMP_ITERATORS_ORIG_STEP (it) = orig_step;
}
return ret;
}
+2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
+
+ * parser.cc (cp_parser_omp_iterators): Use macros for accessing
+ iterator elements.
+ (cp_parser_omp_clause_affinity): Likewise.
+ (cp_parser_omp_clause_depend): Likewise.
+ (cp_parser_omp_clause_from_to): Likewise.
+ (cp_parser_omp_clause_map): Likewise.
+ * semantics.cc (cp_omp_finish_iterators): Likewise.
+
2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
* semantics.cc (handle_omp_array_sections): Add extra argument. Set
pushdecl (iter_var);
*last = make_tree_vec (6);
- TREE_VEC_ELT (*last, 0) = iter_var;
- TREE_VEC_ELT (*last, 1) = begin;
- TREE_VEC_ELT (*last, 2) = end;
- TREE_VEC_ELT (*last, 3) = step;
+ OMP_ITERATORS_VAR (*last) = iter_var;
+ OMP_ITERATORS_BEGIN (*last) = begin;
+ OMP_ITERATORS_END (*last) = end;
+ OMP_ITERATORS_STEP (*last) = step;
last = &TREE_CHAIN (*last);
if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
tree block = poplevel (1, 1, 0);
if (iterators != error_mark_node)
{
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
OMP_CLAUSE_DECL (c) = build_tree_list (iterators,
OMP_CLAUSE_DECL (c));
if (iterators == error_mark_node)
iterators = NULL_TREE;
else
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
}
for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
if (iterators == error_mark_node)
iterators = NULL_TREE;
else
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
}
if (iterators)
if (iterators == error_mark_node)
iterators = NULL_TREE;
else
- TREE_VEC_ELT (iterators, 5) = block;
+ OMP_ITERATORS_BLOCK (iterators) = block;
}
for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
bool ret = false;
for (tree it = iter; it; it = TREE_CHAIN (it))
{
- tree var = TREE_VEC_ELT (it, 0);
- tree begin = TREE_VEC_ELT (it, 1);
- tree end = TREE_VEC_ELT (it, 2);
- tree step = TREE_VEC_ELT (it, 3);
+ tree var = OMP_ITERATORS_VAR (it);
+ tree begin = OMP_ITERATORS_BEGIN (it);
+ tree end = OMP_ITERATORS_END (it);
+ tree step = OMP_ITERATORS_STEP (it);
tree orig_step;
tree type = TREE_TYPE (var);
location_t loc = DECL_SOURCE_LOCATION (var);
tree it2;
for (it2 = TREE_CHAIN (it); it2; it2 = TREE_CHAIN (it2))
{
- tree var2 = TREE_VEC_ELT (it2, 0);
- tree begin2 = TREE_VEC_ELT (it2, 1);
- tree end2 = TREE_VEC_ELT (it2, 2);
- tree step2 = TREE_VEC_ELT (it2, 3);
+ tree var2 = OMP_ITERATORS_VAR (it2);
+ tree begin2 = OMP_ITERATORS_BEGIN (it2);
+ tree end2 = OMP_ITERATORS_END (it2);
+ tree step2 = OMP_ITERATORS_STEP (it2);
location_t loc2 = DECL_SOURCE_LOCATION (var2);
if (cp_walk_tree (&begin2, find_omp_placeholder_r, var, &pset))
{
ret = true;
continue;
}
- TREE_VEC_ELT (it, 1) = begin;
- TREE_VEC_ELT (it, 2) = end;
+ OMP_ITERATORS_BEGIN (it) = begin;
+ OMP_ITERATORS_END (it) = end;
if (processing_template_decl)
- TREE_VEC_ELT (it, 3) = orig_step;
+ OMP_ITERATORS_STEP (it) = orig_step;
else
{
- TREE_VEC_ELT (it, 3) = step;
- TREE_VEC_ELT (it, 4) = orig_step;
+ OMP_ITERATORS_STEP (it) = step;
+ OMP_ITERATORS_ORIG_STEP (it) = orig_step;
}
}
return ret;
+2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
+
+ * trans-openmp.cc (gfc_trans_omp_array_section): Use macros for
+ accessing iterator elements.
+ (handle_iterator): Likewise.
+ (gfc_trans_omp_clauses): Likewise.
+
2025-04-17 Kwok Cheung Yeung <kcyeung@baylibre.com>
* trans-openmp.cc (gfc_trans_omp_clauses): Disable strided updates
for (tree it = iterator; it; it = TREE_CHAIN (it))
{
- ptr = simplify_replace_tree (ptr, TREE_VEC_ELT (it, 0),
- TREE_VEC_ELT (it, 1));
- ptr2 = simplify_replace_tree (ptr2, TREE_VEC_ELT (it, 0),
- TREE_VEC_ELT (it, 1));
+ ptr = simplify_replace_tree (ptr, OMP_ITERATORS_VAR (it),
+ OMP_ITERATORS_BEGIN (it));
+ ptr2 = simplify_replace_tree (ptr2, OMP_ITERATORS_VAR (it),
+ OMP_ITERATORS_BEGIN (it));
}
ptr = fold_build2 (MINUS_EXPR, ptrdiff_type_node, ptr,
fold_convert (ptrdiff_type_node, ptr2));
tree last = make_tree_vec (6);
tree iter_var = gfc_get_symbol_decl (sym);
tree type = TREE_TYPE (iter_var);
- TREE_VEC_ELT (last, 0) = iter_var;
+ OMP_ITERATORS_VAR (last) = iter_var;
DECL_CHAIN (iter_var) = BLOCK_VARS (block);
BLOCK_VARS (block) = iter_var;
gfc_conv_expr (&se, c->expr);
gfc_add_block_to_block (iter_block, &se.pre);
gfc_add_block_to_block (iter_block, &se.post);
- TREE_VEC_ELT (last, 1) = fold_convert (type,
- gfc_evaluate_now (se.expr,
- iter_block));
+ OMP_ITERATORS_BEGIN (last) = fold_convert (type,
+ gfc_evaluate_now (se.expr,
+ iter_block));
/* end */
c = gfc_constructor_next (c);
gfc_init_se (&se, NULL);
gfc_conv_expr (&se, c->expr);
gfc_add_block_to_block (iter_block, &se.pre);
gfc_add_block_to_block (iter_block, &se.post);
- TREE_VEC_ELT (last, 2) = fold_convert (type,
- gfc_evaluate_now (se.expr,
- iter_block));
+ OMP_ITERATORS_END (last) = fold_convert (type,
+ gfc_evaluate_now (se.expr,
+ iter_block));
/* step */
c = gfc_constructor_next (c);
tree step;
}
else
step = build_int_cst (type, 1);
- TREE_VEC_ELT (last, 3) = step;
+ OMP_ITERATORS_STEP (last) = step;
/* orig_step */
- TREE_VEC_ELT (last, 4) = save_expr (step);
+ OMP_ITERATORS_ORIG_STEP (last) = save_expr (step);
TREE_CHAIN (last) = list;
list = last;
}
if (iterator && prev->u2.ns != n->u2.ns)
{
BLOCK_SUBBLOCKS (tree_block) = gfc_finish_block (&iter_block);
- TREE_VEC_ELT (iterator, 5) = tree_block;
+ OMP_ITERATORS_BLOCK (iterator) = tree_block;
for (tree c = omp_clauses; c != prev_clauses;
c = OMP_CLAUSE_CHAIN (c))
OMP_CLAUSE_DECL (c) = build_tree_list (iterator,
if (iterator)
{
BLOCK_SUBBLOCKS (tree_block) = gfc_finish_block (&iter_block);
- TREE_VEC_ELT (iterator, 5) = tree_block;
+ OMP_ITERATORS_BLOCK (iterator) = tree_block;
for (tree c = omp_clauses; c != prev_clauses;
c = OMP_CLAUSE_CHAIN (c))
OMP_CLAUSE_DECL (c) = build_tree_list (iterator,
{
/* Finish previous iterator group. */
BLOCK_SUBBLOCKS (tree_block) = gfc_finish_block (&iter_block);
- TREE_VEC_ELT (iterator, 5) = tree_block;
+ OMP_ITERATORS_BLOCK (iterator) = tree_block;
for (tree c = omp_clauses; c != prev_clauses;
c = OMP_CLAUSE_CHAIN (c))
if (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FIRSTPRIVATE_POINTER
{
/* Finish last iterator group. */
BLOCK_SUBBLOCKS (tree_block) = gfc_finish_block (&iter_block);
- TREE_VEC_ELT (iterator, 5) = tree_block;
+ OMP_ITERATORS_BLOCK (iterator) = tree_block;
for (tree c = omp_clauses; c != prev_clauses;
c = OMP_CLAUSE_CHAIN (c))
if (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FIRSTPRIVATE_POINTER
{
/* Finish previous iterator group. */
BLOCK_SUBBLOCKS (tree_block) = gfc_finish_block (&iter_block);
- TREE_VEC_ELT (iterator, 5) = tree_block;
+ OMP_ITERATORS_BLOCK (iterator) = tree_block;
for (tree c = omp_clauses; c != prev_clauses;
c = OMP_CLAUSE_CHAIN (c))
OMP_CLAUSE_ITERATORS (c) = iterator;
{
/* Finish last iterator group. */
BLOCK_SUBBLOCKS (tree_block) = gfc_finish_block (&iter_block);
- TREE_VEC_ELT (iterator, 5) = tree_block;
+ OMP_ITERATORS_BLOCK (iterator) = tree_block;
for (tree c = omp_clauses; c != prev_clauses;
c = OMP_CLAUSE_CHAIN (c))
OMP_CLAUSE_ITERATORS (c) = iterator;
}
for (tree it = TREE_PURPOSE (t); it; it = TREE_CHAIN (it))
{
- if (gimplify_expr (&TREE_VEC_ELT (it, 1), pre_p, NULL,
+ if (gimplify_expr (&OMP_ITERATORS_BEGIN (it), pre_p, NULL,
is_gimple_val, fb_rvalue) == GS_ERROR
- || gimplify_expr (&TREE_VEC_ELT (it, 2), pre_p, NULL,
+ || gimplify_expr (&OMP_ITERATORS_END (it), pre_p, NULL,
is_gimple_val, fb_rvalue) == GS_ERROR
- || gimplify_expr (&TREE_VEC_ELT (it, 3), pre_p, NULL,
+ || gimplify_expr (&OMP_ITERATORS_STEP (it), pre_p, NULL,
is_gimple_val, fb_rvalue) == GS_ERROR
- || (gimplify_expr (&TREE_VEC_ELT (it, 4), pre_p, NULL,
- is_gimple_val, fb_rvalue)
+ || (gimplify_expr (&OMP_ITERATORS_ORIG_STEP (it), pre_p,
+ NULL, is_gimple_val, fb_rvalue)
== GS_ERROR))
return;
}
last_iter = TREE_PURPOSE (t);
- tree block = TREE_VEC_ELT (TREE_PURPOSE (t), 5);
+ tree block = OMP_ITERATORS_BLOCK (TREE_PURPOSE (t));
last_bind = build3 (BIND_EXPR, void_type_node, BLOCK_VARS (block),
NULL, block);
last_body = &BIND_EXPR_BODY (last_bind);
location_t loc = OMP_CLAUSE_LOCATION (c);
for (tree it = TREE_PURPOSE (t); it; it = TREE_CHAIN (it))
{
- tree var = TREE_VEC_ELT (it, 0);
- tree begin = TREE_VEC_ELT (it, 1);
- tree end = TREE_VEC_ELT (it, 2);
- tree step = TREE_VEC_ELT (it, 3);
+ tree var = OMP_ITERATORS_VAR (it);
+ tree begin = OMP_ITERATORS_BEGIN (it);
+ tree end = OMP_ITERATORS_END (it);
+ tree step = OMP_ITERATORS_STEP (it);
loc = DECL_SOURCE_LOCATION (var);
tree tem = build2_loc (loc, MODIFY_EXPR, void_type_node,
var, begin);
tree tcnt = size_one_node;
for (; it; it = TREE_CHAIN (it))
{
- if (gimplify_expr (&TREE_VEC_ELT (it, 1), pre_p, NULL,
+ if (gimplify_expr (&OMP_ITERATORS_BEGIN (it), pre_p, NULL,
is_gimple_val, fb_rvalue) == GS_ERROR
- || gimplify_expr (&TREE_VEC_ELT (it, 2), pre_p, NULL,
+ || gimplify_expr (&OMP_ITERATORS_END (it), pre_p, NULL,
is_gimple_val, fb_rvalue) == GS_ERROR
- || gimplify_expr (&TREE_VEC_ELT (it, 3), pre_p, NULL,
+ || gimplify_expr (&OMP_ITERATORS_STEP (it), pre_p, NULL,
is_gimple_val, fb_rvalue) == GS_ERROR
- || (gimplify_expr (&TREE_VEC_ELT (it, 4), pre_p, NULL,
+ || (gimplify_expr (&OMP_ITERATORS_ORIG_STEP (it), pre_p, NULL,
is_gimple_val, fb_rvalue) == GS_ERROR))
return NULL_TREE;
- tree var = TREE_VEC_ELT (it, 0);
- tree begin = TREE_VEC_ELT (it, 1);
- tree end = TREE_VEC_ELT (it, 2);
- tree step = TREE_VEC_ELT (it, 3);
- tree orig_step = TREE_VEC_ELT (it, 4);
+ tree var = OMP_ITERATORS_VAR (it);
+ tree begin = OMP_ITERATORS_BEGIN (it);
+ tree end = OMP_ITERATORS_END (it);
+ tree step = OMP_ITERATORS_STEP (it);
+ tree orig_step = OMP_ITERATORS_ORIG_STEP (it);
tree type = TREE_TYPE (var);
tree stype = TREE_TYPE (step);
location_t loc = DECL_SOURCE_LOCATION (var);
{
if (*last_bind)
gimplify_and_add (*last_bind, pre_p);
- tree block = TREE_VEC_ELT (it, 5);
+ tree block = OMP_ITERATORS_BLOCK (it);
tree block_stmts = lang_GNU_Fortran () ? BLOCK_SUBBLOCKS (block) : NULL_TREE;
*last_bind = build3 (BIND_EXPR, void_type_node,
BLOCK_VARS (block), NULL, block);
tree *p = &BIND_EXPR_BODY (*last_bind);
for (; it; it = TREE_CHAIN (it))
{
- tree var = TREE_VEC_ELT (it, 0);
- tree begin = TREE_VEC_ELT (it, 1);
- tree end = TREE_VEC_ELT (it, 2);
- tree step = TREE_VEC_ELT (it, 3);
- tree orig_step = TREE_VEC_ELT (it, 4);
- block = TREE_VEC_ELT (it, 5);
+ tree var = OMP_ITERATORS_VAR (it);
+ tree begin = OMP_ITERATORS_BEGIN (it);
+ tree end = OMP_ITERATORS_END (it);
+ tree step = OMP_ITERATORS_STEP (it);
+ tree orig_step = OMP_ITERATORS_ORIG_STEP (it);
+ block = OMP_ITERATORS_BLOCK (it);
tree type = TREE_TYPE (var);
location_t loc = DECL_SOURCE_LOCATION (var);
/* Emit:
bool need_new_iterators = false;
for (tree it = OMP_CLAUSE_ITERATORS (c); it; it = TREE_CHAIN (it))
{
- tree var = TREE_VEC_ELT (it, 0);
+ tree var = OMP_ITERATORS_VAR (it);
tree t = walk_tree (&OMP_CLAUSE_DECL (c), find_var_decl, var, NULL);
if (t == NULL_TREE)
t = walk_tree (&OMP_CLAUSE_SIZE (c), find_var_decl, var, NULL);
for (tree it = OMP_CLAUSE_ITERATORS (c); it && i < vars.length();
it = TREE_CHAIN (it))
{
- tree var = TREE_VEC_ELT (it, 0);
+ tree var = OMP_ITERATORS_VAR (it);
if (var == vars[i])
{
*new_iters_p = copy_omp_iterator (it);
DECL_NAME (var), TREE_TYPE (var));
DECL_ARTIFICIAL (*new_vars_p) = 1;
DECL_CONTEXT (*new_vars_p) = DECL_CONTEXT (var);
- TREE_VEC_ELT (*new_iters_p, 0) = *new_vars_p;
+ OMP_ITERATORS_VAR (*new_iters_p) = *new_vars_p;
new_iters_p = &TREE_CHAIN (*new_iters_p);
new_vars_p = &DECL_CHAIN (*new_vars_p);
i++;
}
}
- tree old_block = TREE_VEC_ELT (OMP_CLAUSE_ITERATORS (c), 5);
+ tree old_block = OMP_ITERATORS_BLOCK (OMP_CLAUSE_ITERATORS (c));
tree new_block = make_node (BLOCK);
BLOCK_VARS (new_block) = new_vars;
if (BLOCK_SUBBLOCKS (old_block))
BLOCK_SUBBLOCKS (new_block) = BLOCK_SUBBLOCKS (old_block);
BLOCK_SUBBLOCKS (old_block) = NULL_TREE;
}
- TREE_VEC_ELT (new_iters, 5) = new_block;
+ OMP_ITERATORS_BLOCK (new_iters) = new_block;
new_iterators.safe_push (new_iters);
iter_vars.safe_push (vars.copy ());
OMP_CLAUSE_ITERATORS (c) = new_iters;
for (tree it = OMP_CLAUSE_ITERATORS (c); it; it = TREE_CHAIN (it))
{
tree old_var = vars[i++];
- tree new_var = TREE_VEC_ELT (it, 0);
+ tree new_var = OMP_ITERATORS_VAR (it);
remap_omp_iterator_var (&OMP_CLAUSE_DECL (c), old_var, new_var);
remap_omp_iterator_var (&OMP_CLAUSE_SIZE (c), old_var, new_var);
}
int elem_count = TREE_VEC_LENGTH (OMP_CLAUSE_ITERATORS (c));
tree new_iterator = copy_omp_iterator (OMP_CLAUSE_ITERATORS (c),
elem_count + 4);
- TREE_VEC_ELT (new_iterator, elem_count) = loop.body_label;
- TREE_VEC_ELT (new_iterator, elem_count + 1) = loop.index;
- TREE_VEC_ELT (new_iterator, elem_count + 2) = elems;
- TREE_VEC_ELT (new_iterator, elem_count + 3) = loop.count;
+ OMP_ITERATORS_LABEL (new_iterator) = loop.body_label;
+ OMP_ITERATORS_INDEX (new_iterator) = loop.index;
+ OMP_ITERATORS_ELEMS (new_iterator) = elems;
+ OMP_ITERATORS_COUNT (new_iterator) = loop.count;
TREE_CHAIN (new_iterator) = TREE_CHAIN (OMP_CLAUSE_ITERATORS (c));
OMP_CLAUSE_ITERATORS (c) = new_iterator;
{
glabel *label_stmt = as_a<glabel *> (stmt);
tree label = gimple_label_label (label_stmt);
- if (label == TREE_VEC_ELT (iterator, 6))
+ if (label == OMP_ITERATORS_LABEL (iterator))
return loops_seq_p;
}
break;
E.g. "array[i].field" gives "16" (say), not "i * 32 + 16". */
tree it;
for (it = iterator; it; it = TREE_CHAIN (it))
- base = simplify_replace_tree (base, TREE_VEC_ELT (it, 0),
- TREE_VEC_ELT (it, 1));
+ base = simplify_replace_tree (base, OMP_ITERATORS_VAR (it),
+ OMP_ITERATORS_BEGIN (it));
}
base = get_inner_reference (base, &bitsize, &bitpos, &offset, &mode,
return expr;
tree iterator = OMP_CLAUSE_ITERATORS (c);
- tree index = TREE_VEC_ELT (iterator, 7);
- tree elems = TREE_VEC_ELT (iterator, 8);
+ tree index = OMP_ITERATORS_INDEX (iterator);
+ tree elems = OMP_ITERATORS_ELEMS (iterator);
gimple_seq *loop_body_p = enter_omp_iterator_loop_context (c, stmt);
/* IN LOOP BODY: */
return size;
tree iterator = OMP_CLAUSE_ITERATORS (c);
- tree index = TREE_VEC_ELT (iterator, 7);
- tree elems = TREE_VEC_ELT (iterator, 8);
+ tree index = OMP_ITERATORS_INDEX (iterator);
+ tree elems = OMP_ITERATORS_ELEMS (iterator);
gimple_seq *loop_body_p = enter_omp_iterator_loop_context (c, stmt);
/* IN LOOP BODY: */
if (!OMP_CLAUSE_HAS_ITERATORS (c))
continue;
tree iters = OMP_CLAUSE_ITERATORS (c);
- tree elems = TREE_VEC_ELT (iters, 8);
+ tree elems = OMP_ITERATORS_ELEMS (iters);
if (!POINTER_TYPE_P (TREE_TYPE (elems)))
continue;
- tree arr_length = omp_iterator_elems_length (TREE_VEC_ELT (iters, 9));
+ tree arr_length
+ = omp_iterator_elems_length (OMP_ITERATORS_COUNT (iters));
tree call = builtin_decl_explicit (BUILT_IN_MALLOC);
tree size = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MULT_EXPR,
size_type_node, arr_length,
size);
/* Find the first statement '<index> = -1' in the pre-loop statements. */
- tree index = TREE_VEC_ELT (iters, 7);
+ tree index = OMP_ITERATORS_INDEX (iters);
gimple_stmt_iterator gsi;
for (gsi = gsi_start (loops_seq); !gsi_end_p (gsi); gsi_next (&gsi))
{
{
if (!OMP_CLAUSE_HAS_ITERATORS (c))
continue;
- tree elems = TREE_VEC_ELT (OMP_CLAUSE_ITERATORS (c), 8);
+ tree elems = OMP_ITERATORS_ELEMS (OMP_CLAUSE_ITERATORS (c));
if (!POINTER_TYPE_P (TREE_TYPE (elems)))
continue;
tree call = builtin_decl_explicit (BUILT_IN_FREE);
for (int i = 0; i <= 4; i++)
walk_tree (&TREE_VEC_ELT (TREE_PURPOSE (t), i),
copy_tree_body_r, id, NULL);
- if (TREE_VEC_ELT (TREE_PURPOSE (t), 5))
- remap_block (&TREE_VEC_ELT (TREE_PURPOSE (t), 5), id);
+ if (OMP_ITERATORS_BLOCK (TREE_PURPOSE (t)))
+ remap_block (&OMP_ITERATORS_BLOCK (TREE_PURPOSE (t)), id);
walk_tree (&TREE_VALUE (t), copy_tree_body_r, id, NULL);
}
}
{
if (it != iter)
pp_string (pp, ", ");
- dump_generic_node (pp, TREE_TYPE (TREE_VEC_ELT (it, 0)), spc, flags,
+ dump_generic_node (pp, TREE_TYPE (OMP_ITERATORS_VAR (it)), spc, flags,
false);
pp_space (pp);
- dump_generic_node (pp, TREE_VEC_ELT (it, 0), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_VAR (it), spc, flags, false);
pp_equal (pp);
- dump_generic_node (pp, TREE_VEC_ELT (it, 1), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_BEGIN (it), spc, flags, false);
pp_colon (pp);
- dump_generic_node (pp, TREE_VEC_ELT (it, 2), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_END (it), spc, flags, false);
pp_colon (pp);
- dump_generic_node (pp, TREE_VEC_ELT (it, 3), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_STEP (it), spc, flags, false);
}
- if (TREE_VEC_LENGTH (iter) > 6)
+ if (OMP_ITERATORS_EXPANDED_P (iter))
{
pp_string (pp, ", loop_label=");
- dump_generic_node (pp, TREE_VEC_ELT (iter, 6), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_LABEL (iter), spc, flags, false);
pp_string (pp, ", index=");
- dump_generic_node (pp, TREE_VEC_ELT (iter, 7), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_INDEX (iter), spc, flags, false);
pp_string (pp, ", elems=");
- dump_generic_node (pp, TREE_VEC_ELT (iter, 8), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_ELEMS (iter), spc, flags, false);
pp_string (pp, ", elems_count=");
- dump_generic_node (pp, TREE_VEC_ELT (iter, 9), spc, flags, false);
+ dump_generic_node (pp, OMP_ITERATORS_COUNT (iter), spc, flags, false);
}
pp_right_paren (pp);
}
OMP_CLAUSE_FROM, \
OMP_CLAUSE_MAP), 2)
+#define OMP_ITERATORS_VAR(NODE) TREE_VEC_ELT (NODE, 0)
+#define OMP_ITERATORS_BEGIN(NODE) TREE_VEC_ELT (NODE, 1)
+#define OMP_ITERATORS_END(NODE) TREE_VEC_ELT (NODE, 2)
+#define OMP_ITERATORS_STEP(NODE) TREE_VEC_ELT (NODE, 3)
+#define OMP_ITERATORS_ORIG_STEP(NODE) TREE_VEC_ELT (NODE, 4)
+#define OMP_ITERATORS_BLOCK(NODE) TREE_VEC_ELT (NODE, 5)
+#define OMP_ITERATORS_LABEL(NODE) TREE_VEC_ELT (NODE, 6)
+#define OMP_ITERATORS_INDEX(NODE) TREE_VEC_ELT (NODE, 7)
+#define OMP_ITERATORS_ELEMS(NODE) TREE_VEC_ELT (NODE, 8)
+#define OMP_ITERATORS_COUNT(NODE) TREE_VEC_ELT (NODE, 9)
+
+#define OMP_ITERATORS_EXPANDED_P(NODE) (TREE_VEC_LENGTH (NODE) > 6)
+
/* True on OMP_FOR and other OpenMP/OpenACC looping constructs if the loop nest
is non-rectangular. */
#define OMP_FOR_NON_RECTANGULAR(NODE) \
projects / thirdparty / gcc.git / commitdiff
