This patch implements rewriting of SIMT private variables as fields of a
struct by setting DECL_VALUE_EXPR on them and regimplifying statements.
* omp-offload.c: Include langhooks.h, tree-nested.h, stor-layout.h.
(ompdevlow_adjust_simt_enter): New.
(find_simtpriv_var_op): New.
(execute_omp_device_lower): Handle IFN_GOMP_SIMT_ENTER,
IFN_GOMP_SIMT_ENTER_ALLOC, IFN_GOMP_SIMT_EXIT.
---
gcc/omp-offload.c | 115 ++
1 file changed, 115 insertions(+)
diff --git a/gcc/omp-offload.c b/gcc/omp-offload.c
index d73955c..de27942 100644
--- a/gcc/omp-offload.c
+++ b/gcc/omp-offload.c
@@ -33,12 +33,15 @@ along with GCC; see the file COPYING3. If not see
#include "diagnostic-core.h"
#include "fold-const.h"
#include "internal-fn.h"
+#include "langhooks.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "tree-cfg.h"
#include "tree-into-ssa.h"
+#include "tree-nested.h"
+#include "stor-layout.h"
#include "common/common-target.h"
#include "omp-general.h"
#include "omp-offload.h"
@@ -1669,6 +1672,93 @@ make_pass_oacc_device_lower (gcc::context *ctxt)
return new pass_oacc_device_lower (ctxt);
}
+
+
+/* Rewrite GOMP_SIMT_ENTER_ALLOC call given by GSI and remove the preceding
+ GOMP_SIMT_ENTER call identifying the privatized variables, which are
+ turned to structure fields and receive a DECL_VALUE_EXPR accordingly.
+ Set *REGIMPLIFY to true, except if no privatized variables were seen. */
+
+static void
+ompdevlow_adjust_simt_enter (gimple_stmt_iterator *gsi, bool *regimplify)
+{
+ gimple *alloc_stmt = gsi_stmt (*gsi);
+ tree simtrec = gimple_call_lhs (alloc_stmt);
+ tree simduid = gimple_call_arg (alloc_stmt, 0);
+ gimple *enter_stmt = SSA_NAME_DEF_STMT (simduid);
+ gcc_assert (gimple_call_internal_p (enter_stmt, IFN_GOMP_SIMT_ENTER));
+ tree rectype = lang_hooks.types.make_type (RECORD_TYPE);
+ TYPE_ARTIFICIAL (rectype) = TYPE_NAMELESS (rectype) = 1;
+ TREE_ADDRESSABLE (rectype) = 1;
+ TREE_TYPE (simtrec) = build_pointer_type (rectype);
+ for (unsigned i = 1; i < gimple_call_num_args (enter_stmt); i++)
+{
+ tree *argp = gimple_call_arg_ptr (enter_stmt, i);
+ if (*argp == null_pointer_node)
+ continue;
+ gcc_assert (TREE_CODE (*argp) == ADDR_EXPR
+ && VAR_P (TREE_OPERAND (*argp, 0)));
+ tree var = TREE_OPERAND (*argp, 0);
+
+ tree field = build_decl (DECL_SOURCE_LOCATION (var), FIELD_DECL,
+ DECL_NAME (var), TREE_TYPE (var));
+ SET_DECL_ALIGN (field, DECL_ALIGN (var));
+ DECL_USER_ALIGN (field) = DECL_USER_ALIGN (var);
+ TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (var);
+
+ insert_field_into_struct (rectype, field);
+
+ tree t = build_simple_mem_ref (simtrec);
+ t = build3 (COMPONENT_REF, TREE_TYPE (var), t, field, NULL);
+ TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (var);
+ SET_DECL_VALUE_EXPR (var, t);
+ DECL_HAS_VALUE_EXPR_P (var) = 1;
+ *regimplify = true;
+}
+ layout_type (rectype);
+ tree size = TYPE_SIZE_UNIT (rectype);
+ tree align = build_int_cst (TREE_TYPE (size), TYPE_ALIGN_UNIT (rectype));
+
+ alloc_stmt
+= gimple_build_call_internal (IFN_GOMP_SIMT_ENTER_ALLOC, 2, size, align);
+ gimple_call_set_lhs (alloc_stmt, simtrec);
+ gsi_replace (gsi, alloc_stmt, false);
+ gimple_stmt_iterator enter_gsi = gsi_for_stmt (enter_stmt);
+ enter_stmt = gimple_build_assign (simduid, gimple_call_arg (enter_stmt, 0));
+ gsi_replace (_gsi, enter_stmt, false);
+
+ use_operand_p use;
+ gimple *exit_stmt;
+ if (single_imm_use (simtrec, , _stmt))
+{
+ gcc_assert (gimple_call_internal_p (exit_stmt, IFN_GOMP_SIMT_EXIT));
+ gimple_stmt_iterator exit_gsi = gsi_for_stmt (exit_stmt);
+ tree clobber = build_constructor (rectype, NULL);
+ TREE_THIS_VOLATILE (clobber) = 1;
+ exit_stmt = gimple_build_assign (build_simple_mem_ref (simtrec),
clobber);
+ gsi_insert_before (_gsi, exit_stmt, GSI_SAME_STMT);
+}
+ else
+gcc_checking_assert (has_zero_uses (simtrec));
+}
+
+/* Callback for walk_gimple_stmt used to scan for SIMT-privatized variables.
*/
+
+static tree
+find_simtpriv_var_op (tree *tp, int *walk_subtrees, void *)
+{
+ tree t = *tp;
+
+ if (VAR_P (t)
+ && DECL_HAS_VALUE_EXPR_P (t)
+ && lookup_attribute ("omp simt private", DECL_ATTRIBUTES (t)))
+{
+ *walk_subtrees = 0;
+ return t;
+}
+ return NULL_TREE;
+}
+
/* Cleanup uses of SIMT placeholder internal functions: on non-SIMT targets,
VF is 1 and LANE is 0; on SIMT targets, VF is folded to a constant, and
LANE is kept to be expanded to RTL later on. Also cleanup all other SIMT
@@ -1679,6 +1769,7 @@ static unsigned int
execute_omp_device_lower ()
{
int vf = targetm.simt.vf ? targetm.simt.vf () : 1;
+ bool regimplify = false;
basic_block bb;