[PATCH, OpenACC, 2/3] Non-contiguous array support for OpenACC data clauses (re-submission), compiler patches
Chung-Lin Tang
chunglin_tang@mentor.com
Tue Aug 20 12:01:00 GMT 2019
These are the patches for gimplify, omp-low, and include/gomp-constants.h
On issue that Jakub raised in the last review email on omp-low changes [1],
was the use of DECL_IGNORED_P. Because the descriptor variables are created was
create_tmp_var_raw(), they already have DECL_IGNORED_P set, so this shouldn't
be of issue here. The use of '$' in identifier names have also been removed.
[1] https://gcc.gnu.org/ml/gcc-patches/2018-12/msg01297.html
Thanks,
Chung-Lin
gcc/
* gimplify.c (gimplify_scan_omp_clauses): For non-contiguous array map kinds,
make sure bias in each dimension are put into firstprivate variables.
* omp-low.c (struct omp_context):
Add 'hash_map<tree_operand_hash, tree> *non_contiguous_arrays' field, also
added include of "tree-hash-traits.h".
(append_field_to_record_type): New function.
(create_noncontig_array_descr_type): Likewise.
(create_noncontig_array_descr_init_code): Likewise.
(new_omp_context): Add initialize of non_contiguous_arrays field.
(delete_omp_context): Add delete of non_contiguous_arrays field.
(scan_sharing_clauses): For non-contiguous array map kinds, check for
supported dimension structure, and install non-contiguous array variable into
current omp_context.
(lower_omp_target): Add handling for non-contiguous array map kinds.
(noncontig_array_lookup): New function.
(noncontig_array_reference_start): Likewise.
(scan_for_op): Likewise.
(scan_for_reference): Likewise.
(ncarray_create_bias): Likewise.
(ncarray_dimension_peel): Likewise.
(lower_omp_1): Add case to look for start of non-contiguous array reference,
and handle bias adjustments for the code sequence.
* tree-pretty-print.c (dump_omp_clauses): Add cases for printing
GOMP_MAP_NONCONTIG_ARRAY map kinds.
include/
* gomp-constants.h (GOMP_MAP_FLAG_SPECIAL_3): Define.
(enum gomp_map_kind): Add GOMP_MAP_NONCONTIG_ARRAY,
GOMP_MAP_NONCONTIG_ARRAY_TO, GOMP_MAP_NONCONTIG_ARRAY_FROM,
GOMP_MAP_NONCONTIG_ARRAY_TOFROM, GOMP_MAP_NONCONTIG_ARRAY_FORCE_TO,
GOMP_MAP_NONCONTIG_ARRAY_FORCE_FROM, GOMP_MAP_NONCONTIG_ARRAY_FORCE_TOFROM,
GOMP_MAP_NONCONTIG_ARRAY_ALLOC, GOMP_MAP_NONCONTIG_ARRAY_FORCE_ALLOC,
GOMP_MAP_NONCONTIG_ARRAY_FORCE_PRESENT.
(GOMP_MAP_NONCONTIG_ARRAY_P): Define.
-------------- next part --------------
Index: gcc/gimplify.c
===================================================================
--- gcc/gimplify.c (revision 274618)
+++ gcc/gimplify.c (working copy)
@@ -8563,9 +8563,29 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_se
if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
OMP_CLAUSE_SIZE (c) = DECL_P (decl) ? DECL_SIZE_UNIT (decl)
: TYPE_SIZE_UNIT (TREE_TYPE (decl));
- if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
- NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
+ if (OMP_CLAUSE_SIZE (c)
+ && TREE_CODE (OMP_CLAUSE_SIZE (c)) == TREE_LIST
+ && GOMP_MAP_NONCONTIG_ARRAY_P (OMP_CLAUSE_MAP_KIND (c)))
{
+ tree dims = OMP_CLAUSE_SIZE (c);
+ for (tree t = dims; t; t = TREE_CHAIN (t))
+ {
+ /* If a dimension bias isn't a constant, we have to ensure
+ that the value gets transferred to the offload target. */
+ tree low_bound = TREE_PURPOSE (t);
+ if (TREE_CODE (low_bound) != INTEGER_CST)
+ {
+ low_bound = get_initialized_tmp_var (low_bound, pre_p,
+ NULL, false);
+ omp_add_variable (ctx, low_bound,
+ GOVD_FIRSTPRIVATE | GOVD_SEEN);
+ TREE_PURPOSE (t) = low_bound;
+ }
+ }
+ }
+ else if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
+ NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
+ {
remove = true;
break;
}
Index: gcc/omp-low.c
===================================================================
--- gcc/omp-low.c (revision 274618)
+++ gcc/omp-low.c (working copy)
@@ -60,6 +60,7 @@ along with GCC; see the file COPYING3. If not see
#include "hsa-common.h"
#include "stringpool.h"
#include "attribs.h"
+#include "tree-hash-traits.h"
/* Lowering of OMP parallel and workshare constructs proceeds in two
phases. The first phase scans the function looking for OMP statements
@@ -127,6 +128,9 @@ struct omp_context
corresponding tracking loop iteration variables. */
hash_map<tree, tree> *lastprivate_conditional_map;
+ /* Hash map of non-contiguous arrays in this context. */
+ hash_map<tree_operand_hash, tree> *non_contiguous_arrays;
+
/* Nesting depth of this context. Used to beautify error messages re
invalid gotos. The outermost ctx is depth 1, with depth 0 being
reserved for the main body of the function. */
@@ -885,6 +889,137 @@ omp_copy_decl (tree var, copy_body_data *cb)
return error_mark_node;
}
+/* Helper function for create_noncontig_array_descr_type(), to append a new field
+ to a record type. */
+
+static void
+append_field_to_record_type (tree record_type, tree fld_ident, tree fld_type)
+{
+ tree *p, fld = build_decl (UNKNOWN_LOCATION, FIELD_DECL, fld_ident, fld_type);
+ DECL_CONTEXT (fld) = record_type;
+
+ for (p = &TYPE_FIELDS (record_type); *p; p = &DECL_CHAIN (*p))
+ ;
+ *p = fld;
+}
+
+/* Create type for non-contiguous array descriptor. Returns created type, and
+ returns the number of dimensions in *DIM_NUM. */
+
+static tree
+create_noncontig_array_descr_type (tree decl, tree dims, int *dim_num)
+{
+ int n = 0;
+ tree array_descr_type, name, x;
+ gcc_assert (TREE_CODE (dims) == TREE_LIST);
+
+ array_descr_type = lang_hooks.types.make_type (RECORD_TYPE);
+ name = create_tmp_var_name (".omp_noncontig_array_descr_type");
+ name = build_decl (UNKNOWN_LOCATION, TYPE_DECL, name, array_descr_type);
+ DECL_ARTIFICIAL (name) = 1;
+ DECL_NAMELESS (name) = 1;
+ TYPE_NAME (array_descr_type) = name;
+ TYPE_ARTIFICIAL (array_descr_type) = 1;
+
+ /* Main starting pointer/array. */
+ tree main_var_type = TREE_TYPE (decl);
+ if (TREE_CODE (main_var_type) == REFERENCE_TYPE)
+ main_var_type = TREE_TYPE (main_var_type);
+ append_field_to_record_type (array_descr_type, DECL_NAME (decl),
+ (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
+ ? main_var_type
+ : build_pointer_type (main_var_type)));
+ /* Number of dimensions. */
+ append_field_to_record_type (array_descr_type, get_identifier ("__dim_num"),
+ sizetype);
+
+ for (x = dims; x; x = TREE_CHAIN (x), n++)
+ {
+ char *fldname;
+ /* One for the start index. */
+ ASM_FORMAT_PRIVATE_NAME (fldname, "__dim_base", n);
+ append_field_to_record_type (array_descr_type, get_identifier (fldname),
+ sizetype);
+ /* One for the length. */
+ ASM_FORMAT_PRIVATE_NAME (fldname, "__dim_length", n);
+ append_field_to_record_type (array_descr_type, get_identifier (fldname),
+ sizetype);
+ /* One for the element size. */
+ ASM_FORMAT_PRIVATE_NAME (fldname, "__dim_elem_size", n);
+ append_field_to_record_type (array_descr_type, get_identifier (fldname),
+ sizetype);
+ /* One for is_array flag. */
+ ASM_FORMAT_PRIVATE_NAME (fldname, "__dim_is_array", n);
+ append_field_to_record_type (array_descr_type, get_identifier (fldname),
+ sizetype);
+ }
+
+ layout_type (array_descr_type);
+ *dim_num = n;
+ return array_descr_type;
+}
+
+/* Generate code sequence for initializing non-contiguous array descriptor. */
+
+static void
+create_noncontig_array_descr_init_code (tree array_descr, tree array_var,
+ tree dimensions, int dim_num,
+ gimple_seq *ilist)
+{
+ tree fld, fldref;
+ tree array_descr_type = TREE_TYPE (array_descr);
+ tree dim_type = TREE_TYPE (array_var);
+
+ fld = TYPE_FIELDS (array_descr_type);
+ fldref = omp_build_component_ref (array_descr, fld);
+ gimplify_assign (fldref, (TREE_CODE (dim_type) == ARRAY_TYPE
+ ? build_fold_addr_expr (array_var) : array_var),
+ ilist);
+
+ if (TREE_CODE (dim_type) == REFERENCE_TYPE)
+ dim_type = TREE_TYPE (dim_type);
+
+ fld = TREE_CHAIN (fld);
+ fldref = omp_build_component_ref (array_descr, fld);
+ gimplify_assign (fldref, build_int_cst (sizetype, dim_num), ilist);
+
+ while (dimensions)
+ {
+ tree dim_base = fold_convert (sizetype, TREE_PURPOSE (dimensions));
+ tree dim_length = fold_convert (sizetype, TREE_VALUE (dimensions));
+ tree dim_elem_size = TYPE_SIZE_UNIT (TREE_TYPE (dim_type));
+ tree dim_is_array = (TREE_CODE (dim_type) == ARRAY_TYPE
+ ? integer_one_node : integer_zero_node);
+ /* Set base. */
+ fld = TREE_CHAIN (fld);
+ fldref = omp_build_component_ref (array_descr, fld);
+ dim_base = fold_build2 (MULT_EXPR, sizetype, dim_base, dim_elem_size);
+ gimplify_assign (fldref, dim_base, ilist);
+
+ /* Set length. */
+ fld = TREE_CHAIN (fld);
+ fldref = omp_build_component_ref (array_descr, fld);
+ dim_length = fold_build2 (MULT_EXPR, sizetype, dim_length, dim_elem_size);
+ gimplify_assign (fldref, dim_length, ilist);
+
+ /* Set elem_size. */
+ fld = TREE_CHAIN (fld);
+ fldref = omp_build_component_ref (array_descr, fld);
+ dim_elem_size = fold_convert (sizetype, dim_elem_size);
+ gimplify_assign (fldref, dim_elem_size, ilist);
+
+ /* Set is_array flag. */
+ fld = TREE_CHAIN (fld);
+ fldref = omp_build_component_ref (array_descr, fld);
+ dim_is_array = fold_convert (sizetype, dim_is_array);
+ gimplify_assign (fldref, dim_is_array, ilist);
+
+ dimensions = TREE_CHAIN (dimensions);
+ dim_type = TREE_TYPE (dim_type);
+ }
+ gcc_assert (TREE_CHAIN (fld) == NULL_TREE);
+}
+
/* Create a new context, with OUTER_CTX being the surrounding context. */
static omp_context *
@@ -921,6 +1056,8 @@ new_omp_context (gimple *stmt, omp_context *outer_
ctx->cb.decl_map = new hash_map<tree, tree>;
+ ctx->non_contiguous_arrays = new hash_map<tree_operand_hash, tree>;
+
return ctx;
}
@@ -1003,6 +1140,8 @@ delete_omp_context (splay_tree_value value)
delete ctx->lastprivate_conditional_map;
+ delete ctx->non_contiguous_arrays;
+
XDELETE (ctx);
}
@@ -1353,6 +1492,42 @@ scan_sharing_clauses (tree clauses, omp_context *c
install_var_local (decl, ctx);
break;
}
+
+ if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
+ && GOMP_MAP_NONCONTIG_ARRAY_P (OMP_CLAUSE_MAP_KIND (c)))
+ {
+ tree array_decl = OMP_CLAUSE_DECL (c);
+ tree array_dimensions = OMP_CLAUSE_SIZE (c);
+ tree array_type = TREE_TYPE (array_decl);
+ bool by_ref = (TREE_CODE (array_type) == ARRAY_TYPE
+ ? true : false);
+
+ /* Checking code to ensure we only have arrays at top dimension.
+ This limitation might be lifted in the future. */
+ if (TREE_CODE (array_type) == REFERENCE_TYPE)
+ array_type = TREE_TYPE (array_type);
+ tree t = array_type, prev_t = NULL_TREE;
+ while (t)
+ {
+ if (TREE_CODE (t) == ARRAY_TYPE && prev_t)
+ {
+ error_at (gimple_location (ctx->stmt), "array types are"
+ " only allowed at outermost dimension of"
+ " non-contiguous array");
+ break;
+ }
+ prev_t = t;
+ t = TREE_TYPE (t);
+ }
+
+ install_var_field (array_decl, by_ref, 3, ctx);
+ tree new_var = install_var_local (array_decl, ctx);
+
+ bool existed = ctx->non_contiguous_arrays->put (new_var, array_dimensions);
+ gcc_assert (!existed);
+ break;
+ }
+
if (DECL_P (decl))
{
if (DECL_SIZE (decl)
@@ -2583,6 +2758,50 @@ scan_omp_single (gomp_single *stmt, omp_context *o
layout_type (ctx->record_type);
}
+/* Reorder clauses so that non-contiguous array map clauses are placed at the very
+ front of the chain. */
+
+static void
+reorder_noncontig_array_clauses (tree *clauses_ptr)
+{
+ tree c, clauses = *clauses_ptr;
+ tree prev_clause = NULL_TREE, next_clause;
+ tree array_clauses = NULL_TREE, array_clauses_tail = NULL_TREE;
+
+ for (c = clauses; c; c = next_clause)
+ {
+ next_clause = OMP_CLAUSE_CHAIN (c);
+
+ if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
+ && GOMP_MAP_NONCONTIG_ARRAY_P (OMP_CLAUSE_MAP_KIND (c)))
+ {
+ /* Unchain c from clauses. */
+ if (c == clauses)
+ clauses = next_clause;
+
+ /* Link on to array_clauses. */
+ if (array_clauses_tail)
+ OMP_CLAUSE_CHAIN (array_clauses_tail) = c;
+ else
+ array_clauses = c;
+ array_clauses_tail = c;
+
+ if (prev_clause)
+ OMP_CLAUSE_CHAIN (prev_clause) = next_clause;
+ continue;
+ }
+
+ prev_clause = c;
+ }
+
+ /* Place non-contiguous array clauses at the start of the clause list. */
+ if (array_clauses)
+ {
+ OMP_CLAUSE_CHAIN (array_clauses_tail) = clauses;
+ *clauses_ptr = array_clauses;
+ }
+}
+
/* Scan a GIMPLE_OMP_TARGET. */
static void
@@ -2591,7 +2810,6 @@ scan_omp_target (gomp_target *stmt, omp_context *o
omp_context *ctx;
tree name;
bool offloaded = is_gimple_omp_offloaded (stmt);
- tree clauses = gimple_omp_target_clauses (stmt);
ctx = new_omp_context (stmt, outer_ctx);
ctx->field_map = splay_tree_new (splay_tree_compare_pointers, 0, 0);
@@ -2610,6 +2828,14 @@ scan_omp_target (gomp_target *stmt, omp_context *o
gimple_omp_target_set_child_fn (stmt, ctx->cb.dst_fn);
}
+ /* If is OpenACC construct, put non-contiguous array clauses (if any)
+ in front of clause chain. The runtime can then test the first to see
+ if the additional map processing for them is required. */
+ if (is_gimple_omp_oacc (stmt))
+ reorder_noncontig_array_clauses (gimple_omp_target_clauses_ptr (stmt));
+
+ tree clauses = gimple_omp_target_clauses (stmt);
+
scan_sharing_clauses (clauses, ctx);
scan_omp (gimple_omp_body_ptr (stmt), ctx);
@@ -11326,6 +11552,15 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp
case GOMP_MAP_FORCE_PRESENT:
case GOMP_MAP_FORCE_DEVICEPTR:
case GOMP_MAP_DEVICE_RESIDENT:
+ case GOMP_MAP_NONCONTIG_ARRAY_TO:
+ case GOMP_MAP_NONCONTIG_ARRAY_FROM:
+ case GOMP_MAP_NONCONTIG_ARRAY_TOFROM:
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_TO:
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_FROM:
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_TOFROM:
+ case GOMP_MAP_NONCONTIG_ARRAY_ALLOC:
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_ALLOC:
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_PRESENT:
case GOMP_MAP_LINK:
gcc_assert (is_gimple_omp_oacc (stmt));
break;
@@ -11388,7 +11623,14 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp
if (offloaded && !(OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
&& OMP_CLAUSE_MAP_IN_REDUCTION (c)))
{
- x = build_receiver_ref (var, true, ctx);
+ tree var_type = TREE_TYPE (var);
+ bool rcv_by_ref =
+ (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
+ && GOMP_MAP_NONCONTIG_ARRAY_P (OMP_CLAUSE_MAP_KIND (c))
+ && TREE_CODE (var_type) != ARRAY_TYPE
+ ? false : true);
+
+ x = build_receiver_ref (var, rcv_by_ref, ctx);
tree new_var = lookup_decl (var, ctx);
if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
@@ -11635,6 +11877,24 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp
avar = build_fold_addr_expr (avar);
gimplify_assign (x, avar, &ilist);
}
+ else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
+ && GOMP_MAP_NONCONTIG_ARRAY_P (OMP_CLAUSE_MAP_KIND (c)))
+ {
+ int dim_num;
+ tree dimensions = OMP_CLAUSE_SIZE (c);
+
+ tree array_descr_type =
+ create_noncontig_array_descr_type (OMP_CLAUSE_DECL (c),
+ dimensions, &dim_num);
+ tree array_descr =
+ create_tmp_var_raw (array_descr_type, ".omp_noncontig_array_descr");
+ gimple_add_tmp_var (array_descr);
+
+ create_noncontig_array_descr_init_code
+ (array_descr, ovar, dimensions, dim_num, &ilist);
+
+ gimplify_assign (x, build_fold_addr_expr (array_descr), &ilist);
+ }
else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE)
{
gcc_assert (is_gimple_omp_oacc (ctx->stmt));
@@ -11695,6 +11955,9 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp
s = TREE_TYPE (s);
s = TYPE_SIZE_UNIT (s);
}
+ else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
+ && GOMP_MAP_NONCONTIG_ARRAY_P (OMP_CLAUSE_MAP_KIND (c)))
+ s = NULL_TREE;
else
s = OMP_CLAUSE_SIZE (c);
if (s == NULL_TREE)
@@ -12384,7 +12647,202 @@ lower_omp_grid_body (gimple_stmt_iterator *gsi_p,
gimple_build_omp_return (false));
}
+/* Helper to lookup non-contiguous arrays through nested omp contexts. Returns
+ TREE_LIST of dimensions, and the CTX where it was found in *CTX_P. */
+static tree
+noncontig_array_lookup (tree t, omp_context **ctx_p)
+{
+ omp_context *c = *ctx_p;
+ while (c)
+ {
+ tree *dims = c->non_contiguous_arrays->get (t);
+ if (dims)
+ {
+ *ctx_p = c;
+ return *dims;
+ }
+ c = c->outer;
+ }
+ return NULL_TREE;
+}
+
+/* Tests if this gimple STMT is the start of a non-contiguous array access
+ sequence. Returns true if found, and also returns the gimple operand ptr
+ and dimensions tree list through *OUT_REF and *OUT_DIMS respectively. */
+
+static bool
+noncontig_array_reference_start (gimple *stmt, omp_context **ctx_p,
+ tree **out_ref, tree *out_dims)
+{
+ if (gimple_code (stmt) == GIMPLE_ASSIGN)
+ for (unsigned i = 1; i < gimple_num_ops (stmt); i++)
+ {
+ tree *op = gimple_op_ptr (stmt, i), dims;
+ if (TREE_CODE (*op) == ARRAY_REF)
+ op = &TREE_OPERAND (*op, 0);
+ if (TREE_CODE (*op) == MEM_REF)
+ op = &TREE_OPERAND (*op, 0);
+ if ((dims = noncontig_array_lookup (*op, ctx_p)) != NULL_TREE)
+ {
+ *out_ref = op;
+ *out_dims = dims;
+ return true;
+ }
+ }
+ return false;
+}
+
+static tree
+scan_for_op (tree *tp, int *walk_subtrees, void *data)
+{
+ struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
+ tree t = *tp;
+ tree op = (tree) wi->info;
+ *walk_subtrees = 1;
+ if (operand_equal_p (t, op, 0))
+ {
+ wi->info = tp;
+ return t;
+ }
+ return NULL_TREE;
+}
+
+static tree *
+scan_for_reference (gimple *stmt, tree op)
+{
+ struct walk_stmt_info wi;
+ memset (&wi, 0, sizeof (wi));
+ wi.info = op;
+ if (walk_gimple_op (stmt, scan_for_op, &wi))
+ return (tree *) wi.info;
+ return NULL;
+}
+
+static tree
+ncarray_create_bias (tree orig_bias, tree unit_type)
+{
+ return build2 (MULT_EXPR, sizetype, fold_convert (sizetype, orig_bias),
+ TYPE_SIZE_UNIT (unit_type));
+}
+
+/* Main worker for adjusting non-contiguous array accesses, handles the
+ adjustment of many cases of statement forms, and called multiple times
+ to 'peel' away each dimension. */
+
+static gimple_stmt_iterator
+ncarray_dimension_peel (omp_context *ctx,
+ gimple_stmt_iterator gsi, tree orig_da,
+ tree *op_ptr, tree *type_ptr, tree *dims_ptr)
+{
+ gimple *stmt = gsi_stmt (gsi);
+ tree lhs = gimple_assign_lhs (stmt);
+ tree rhs = gimple_assign_rhs1 (stmt);
+
+ if (gimple_num_ops (stmt) == 2
+ && TREE_CODE (rhs) == MEM_REF
+ && operand_equal_p (*op_ptr, TREE_OPERAND (rhs, 0), 0)
+ && !operand_equal_p (orig_da, TREE_OPERAND (rhs, 0), 0)
+ && (TREE_OPERAND (rhs, 1) == NULL_TREE
+ || integer_zerop (TREE_OPERAND (rhs, 1))))
+ {
+ gcc_assert (TREE_CODE (TREE_TYPE (*type_ptr)) == POINTER_TYPE);
+ *type_ptr = TREE_TYPE (*type_ptr);
+ }
+ else
+ {
+ gimple *g;
+ gimple_seq ilist = NULL;
+ tree bias, t;
+ tree op = *op_ptr;
+ tree orig_type = *type_ptr;
+ tree orig_bias = TREE_PURPOSE (*dims_ptr);
+ bool by_ref = false;
+
+ if (TREE_CODE (orig_bias) != INTEGER_CST)
+ orig_bias = lookup_decl (orig_bias, ctx);
+
+ if (gimple_num_ops (stmt) == 2)
+ {
+ if (TREE_CODE (rhs) == ADDR_EXPR)
+ {
+ rhs = TREE_OPERAND (rhs, 0);
+ *dims_ptr = NULL_TREE;
+ }
+
+ if (TREE_CODE (rhs) == ARRAY_REF
+ && TREE_CODE (TREE_OPERAND (rhs, 0)) == MEM_REF
+ && operand_equal_p (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0),
+ *op_ptr, 0))
+ {
+ bias = ncarray_create_bias (orig_bias,
+ TREE_TYPE (TREE_TYPE (orig_type)));
+ *type_ptr = TREE_TYPE (TREE_TYPE (orig_type));
+ }
+ else if (TREE_CODE (rhs) == ARRAY_REF
+ && TREE_CODE (TREE_OPERAND (rhs, 0)) == VAR_DECL
+ && operand_equal_p (TREE_OPERAND (rhs, 0), *op_ptr, 0))
+ {
+ tree ptr_type = build_pointer_type (orig_type);
+ op = create_tmp_var (ptr_type);
+ gimplify_assign (op, build_fold_addr_expr (TREE_OPERAND (rhs, 0)),
+ &ilist);
+ bias = ncarray_create_bias (orig_bias, TREE_TYPE (orig_type));
+ *type_ptr = TREE_TYPE (orig_type);
+ orig_type = ptr_type;
+ by_ref = true;
+ }
+ else if (TREE_CODE (rhs) == MEM_REF
+ && operand_equal_p (*op_ptr, TREE_OPERAND (rhs, 0), 0)
+ && TREE_OPERAND (rhs, 1) != NULL_TREE)
+ {
+ bias = ncarray_create_bias (orig_bias, TREE_TYPE (orig_type));
+ *type_ptr = TREE_TYPE (orig_type);
+ }
+ else if (TREE_CODE (lhs) == MEM_REF
+ && operand_equal_p (*op_ptr, TREE_OPERAND (lhs, 0), 0))
+ {
+ if (*dims_ptr != NULL_TREE)
+ {
+ gcc_assert (TREE_CHAIN (*dims_ptr) == NULL_TREE);
+ bias = ncarray_create_bias (orig_bias, TREE_TYPE (orig_type));
+ *type_ptr = TREE_TYPE (orig_type);
+ }
+ else
+ /* This should be the end of the non-contiguous array access
+ sequence. */
+ return gsi;
+ }
+ else
+ gcc_unreachable ();
+ }
+ else if (gimple_num_ops (stmt) == 3
+ && gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
+ && operand_equal_p (*op_ptr, rhs, 0))
+ {
+ bias = ncarray_create_bias (orig_bias, TREE_TYPE (orig_type));
+ }
+ else
+ gcc_unreachable ();
+
+ bias = fold_build1 (NEGATE_EXPR, sizetype, bias);
+ bias = fold_build2 (POINTER_PLUS_EXPR, orig_type, op, bias);
+
+ t = create_tmp_var (by_ref ? build_pointer_type (orig_type) : orig_type);
+
+ g = gimplify_assign (t, bias, &ilist);
+ gsi_insert_seq_before (&gsi, ilist, GSI_NEW_STMT);
+ *op_ptr = gimple_assign_lhs (g);
+
+ if (by_ref)
+ *op_ptr = build2 (MEM_REF, TREE_TYPE (orig_type), *op_ptr,
+ build_int_cst (orig_type, 0));
+ *dims_ptr = TREE_CHAIN (*dims_ptr);
+ }
+
+ return gsi;
+}
+
/* Callback for lower_omp_1. Return non-NULL if *tp needs to be
regimplified. If DATA is non-NULL, lower_omp_1 is outside
of OMP context, but with task_shared_vars set. */
@@ -12709,6 +13167,48 @@ lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_cont
default:
regimplify:
+ /* If we detect the start of a non-contiguous array reference sequence,
+ scan and do the needed adjustments. */
+ tree dims, *op_ptr;
+ omp_context *ncarray_ctx = ctx;
+ if (ncarray_ctx
+ && noncontig_array_reference_start (stmt, &ncarray_ctx, &op_ptr, &dims))
+ {
+ bool started = false;
+ tree orig_array_var = *op_ptr;
+ tree curr_type = TREE_TYPE (orig_array_var);
+
+ gimple_stmt_iterator gsi = *gsi_p, new_gsi;
+ while (op_ptr)
+ {
+ if (!is_gimple_assign (gsi_stmt (gsi))
+ || ((gimple_assign_single_p (gsi_stmt (gsi))
+ || gimple_assign_cast_p (gsi_stmt (gsi)))
+ && *op_ptr == gimple_assign_rhs1 (gsi_stmt (gsi))))
+ break;
+
+ new_gsi = ncarray_dimension_peel (ncarray_ctx, gsi, orig_array_var,
+ op_ptr, &curr_type, &dims);
+ if (!started)
+ {
+ /* Point 'stmt' to the start of the newly added
+ sequence. */
+ started = true;
+ *gsi_p = new_gsi;
+ stmt = gsi_stmt (*gsi_p);
+ }
+ if (dims == NULL_TREE)
+ break;
+
+ tree next_op = gimple_assign_lhs (gsi_stmt (gsi));
+ do {
+ gsi_next (&gsi);
+ op_ptr = scan_for_reference (gsi_stmt (gsi), next_op);
+ }
+ while (!op_ptr);
+ }
+ }
+
if ((ctx || task_shared_vars)
&& walk_gimple_op (stmt, lower_omp_regimplify_p,
ctx ? NULL : &wi))
Index: gcc/tree-pretty-print.c
===================================================================
--- gcc/tree-pretty-print.c (revision 274618)
+++ gcc/tree-pretty-print.c (working copy)
@@ -849,6 +849,33 @@ dump_omp_clause (pretty_printer *pp, tree clause,
case GOMP_MAP_LINK:
pp_string (pp, "link");
break;
+ case GOMP_MAP_NONCONTIG_ARRAY_TO:
+ pp_string (pp, "to,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_FROM:
+ pp_string (pp, "from,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_TOFROM:
+ pp_string (pp, "tofrom,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_TO:
+ pp_string (pp, "force_to,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_FROM:
+ pp_string (pp, "force_from,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_TOFROM:
+ pp_string (pp, "force_tofrom,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_ALLOC:
+ pp_string (pp, "alloc,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_ALLOC:
+ pp_string (pp, "force_alloc,noncontig_array");
+ break;
+ case GOMP_MAP_NONCONTIG_ARRAY_FORCE_PRESENT:
+ pp_string (pp, "force_present,noncontig_array");
+ break;
default:
gcc_unreachable ();
}
@@ -870,6 +897,10 @@ dump_omp_clause (pretty_printer *pp, tree clause,
case GOMP_MAP_TO_PSET:
pp_string (pp, " [pointer set, len: ");
break;
+ case GOMP_MAP_NONCONTIG_ARRAY:
+ gcc_assert (TREE_CODE (OMP_CLAUSE_SIZE (clause)) == TREE_LIST);
+ pp_string (pp, " [dimensions: ");
+ break;
default:
pp_string (pp, " [len: ");
break;
Index: include/gomp-constants.h
===================================================================
--- include/gomp-constants.h (revision 274618)
+++ include/gomp-constants.h (working copy)
@@ -40,6 +40,7 @@
#define GOMP_MAP_FLAG_SPECIAL_0 (1 << 2)
#define GOMP_MAP_FLAG_SPECIAL_1 (1 << 3)
#define GOMP_MAP_FLAG_SPECIAL_2 (1 << 4)
+#define GOMP_MAP_FLAG_SPECIAL_3 (1 << 5)
#define GOMP_MAP_FLAG_SPECIAL (GOMP_MAP_FLAG_SPECIAL_1 \
| GOMP_MAP_FLAG_SPECIAL_0)
/* Flag to force a specific behavior (or else, trigger a run-time error). */
@@ -127,6 +128,26 @@ enum gomp_map_kind
/* Decrement usage count and deallocate if zero. */
GOMP_MAP_RELEASE = (GOMP_MAP_FLAG_SPECIAL_2
| GOMP_MAP_DELETE),
+ /* Mapping kinds for non-contiguous arrays. */
+ GOMP_MAP_NONCONTIG_ARRAY = (GOMP_MAP_FLAG_SPECIAL_3),
+ GOMP_MAP_NONCONTIG_ARRAY_TO = (GOMP_MAP_NONCONTIG_ARRAY
+ | GOMP_MAP_TO),
+ GOMP_MAP_NONCONTIG_ARRAY_FROM = (GOMP_MAP_NONCONTIG_ARRAY
+ | GOMP_MAP_FROM),
+ GOMP_MAP_NONCONTIG_ARRAY_TOFROM = (GOMP_MAP_NONCONTIG_ARRAY
+ | GOMP_MAP_TOFROM),
+ GOMP_MAP_NONCONTIG_ARRAY_FORCE_TO = (GOMP_MAP_NONCONTIG_ARRAY_TO
+ | GOMP_MAP_FLAG_FORCE),
+ GOMP_MAP_NONCONTIG_ARRAY_FORCE_FROM = (GOMP_MAP_NONCONTIG_ARRAY_FROM
+ | GOMP_MAP_FLAG_FORCE),
+ GOMP_MAP_NONCONTIG_ARRAY_FORCE_TOFROM = (GOMP_MAP_NONCONTIG_ARRAY_TOFROM
+ | GOMP_MAP_FLAG_FORCE),
+ GOMP_MAP_NONCONTIG_ARRAY_ALLOC = (GOMP_MAP_NONCONTIG_ARRAY
+ | GOMP_MAP_ALLOC),
+ GOMP_MAP_NONCONTIG_ARRAY_FORCE_ALLOC = (GOMP_MAP_NONCONTIG_ARRAY
+ | GOMP_MAP_FORCE_ALLOC),
+ GOMP_MAP_NONCONTIG_ARRAY_FORCE_PRESENT = (GOMP_MAP_NONCONTIG_ARRAY
+ | GOMP_MAP_FORCE_PRESENT),
/* Internal to GCC, not used in libgomp. */
/* Do not map, but pointer assign a pointer instead. */
@@ -155,6 +176,8 @@ enum gomp_map_kind
#define GOMP_MAP_ALWAYS_P(X) \
(GOMP_MAP_ALWAYS_TO_P (X) || ((X) == GOMP_MAP_ALWAYS_FROM))
+#define GOMP_MAP_NONCONTIG_ARRAY_P(X) \
+ ((X) & GOMP_MAP_NONCONTIG_ARRAY)
/* Asynchronous behavior. Keep in sync with
libgomp/{openacc.h,openacc.f90,openacc_lib.h}:acc_async_t. */
More information about the Gcc-patches
mailing list