openacc: Handle internal function calls in pass_lim

The loop invariant motion pass correctly refuses to move statements
out of a loop if any other statement in the loop is unanalyzable.  The
pass does not know how to handle the OpenACC internal function calls
which was not necessary until recently when the OpenACC device
lowering pass was moved to a later position in the pass pipeline.

This commit changes pass_lim to ignore the OpenACC internal function
calls which do not contain any memory references. The hoisting enabled
by this change can be useful for the data-dependence analysis in
Graphite; for instance, in the outlined functions for OpenACC regions,
all invariant accesses to the ".omp_data_i" struct should be hoisted
out of the OpenACC loop.  This is particularly important for variables
that were scalars in the original loop and which have been turned into
accesses to the struct by the outlining process.  Not hoisting those
can prevent scalar evolution analysis which is crucial for Graphite.
Since any hoisting that introduces intermediate names - and hence,
"fake" dependences - inside the analyzed nest can be harmful to
data-dependence analysis, a flag to restrict the hoisting in OpenACC
functions is added to the pass. The pass instance that executes before
Graphite now runs with this flag set to true and the pass instance
after Graphite runs unrestricted.

A more precise way of selecting the statements for which hoisting
should be enabled is left for a future improvement.

gcc/ChangeLog:
        * passes.def: Set restrict_oacc_hoisting to true for the early
	pass_lim instance.
	* tree-ssa-loop-im.cc (movement_possibility): Add
	restrict_oacc_hoisting flag to function; restrict movement if set.
	(compute_invariantness): Add restrict_oacc_hoisting flag and pass it on.
        (gather_mem_refs_stmt): Skip IFN_GOACC_LOOP and IFN_UNIQUE
	calls.
        (loop_invariant_motion_in_fun): Add restrict_oacc_hoisting flag and
	pass it on.
        (pass_lim::execute): Pass on new flags.
	* tree-ssa-loop-manip.h (loop_invariant_motion_in_fun): Adjust declaration.
	* gimple-loop-interchange.cc (pass_linterchange::execute): Adjust call to
	loop_invariant_motion_in_fun.

diff --git a/gcc/ChangeLog.omp b/gcc/ChangeLog.omp
index 46da06d022f53943d1cf76264352f5366cae8057..88e5379347f3e5a3893ad9e703b93a52176830ef 100644 (file)
--- a/gcc/ChangeLog.omp
+++ b/gcc/ChangeLog.omp
@@ -1,3 +1,19 @@
+2021-11-16  Frederik Harwath  <frederik@codesourcery.com>
+
+       * passes.def: Set restrict_oacc_hoisting to true for the early
+       pass_lim instance.
+       * tree-ssa-loop-im.cc (movement_possibility): Add
+       restrict_oacc_hoisting flag to function; restrict movement if set.
+       (compute_invariantness): Add restrict_oacc_hoisting flag and pass it on.
+       (gather_mem_refs_stmt): Skip IFN_GOACC_LOOP and IFN_UNIQUE
+       calls.
+       (loop_invariant_motion_in_fun): Add restrict_oacc_hoisting flag and
+       pass it on.
+       (pass_lim::execute): Pass on new flags.
+       * tree-ssa-loop-manip.h (loop_invariant_motion_in_fun): Adjust declaration.
+       * gimple-loop-interchange.cc (pass_linterchange::execute): Adjust call to
+       loop_invariant_motion_in_fun.
+
 2021-11-16  Andrew Stubbs  <ams@codesourcery.com>
 
        * common.opt: Add flag Wopenacc-false-independent.

diff --git a/gcc/gimple-loop-interchange.cc b/gcc/gimple-loop-interchange.cc
index 53adc02acc21bbc89492abf09e685451b1d746ea..8c6866a066f2d371564b0fbeb6305e5f98adcf10 100644 (file)
--- a/gcc/gimple-loop-interchange.cc
+++ b/gcc/gimple-loop-interchange.cc
@@ -2107,7 +2107,7 @@ pass_linterchange::execute (function *fun)
   if (changed_p)
     {
       unsigned todo = TODO_update_ssa_only_virtuals;
-      todo |= loop_invariant_motion_in_fun (cfun, false);
+      todo |= loop_invariant_motion_in_fun (cfun, false, false);
       scev_reset ();
       return todo;
     }

diff --git a/gcc/passes.def b/gcc/passes.def
index 927ba61e2efeb2b01f2339950bca2be03e0ee065..3ab73cf2c7379c23975323e3f8ad37882ac0a2ee 100644 (file)
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -254,7 +254,7 @@ along with GCC; see the file COPYING3.  If not see
       NEXT_PASS (pass_cse_sincos);
       NEXT_PASS (pass_optimize_bswap);
       NEXT_PASS (pass_laddress);
-      NEXT_PASS (pass_lim);
+      NEXT_PASS (pass_lim, true /* restrict_oacc_hoisting */);
       NEXT_PASS (pass_walloca, false);
       NEXT_PASS (pass_pre);
       NEXT_PASS (pass_sink_code, false /* unsplit edges */);

diff --git a/gcc/tree-ssa-loop-im.cc b/gcc/tree-ssa-loop-im.cc
index 6d9316eed1ff7d981681d1249bdbede6e723e5c1..3e09bb19ed30c3e6d3e2f711e02946d8bc258c38 100644 (file)
--- a/gcc/tree-ssa-loop-im.cc
+++ b/gcc/tree-ssa-loop-im.cc
@@ -47,6 +47,8 @@ along with GCC; see the file COPYING3.  If not see
 #include "builtins.h"
 #include "tree-dfa.h"
 #include "dbgcnt.h"
+#include "graphite-oacc.h"
+#include "internal-fn.h"
 
 /* TODO:  Support for predicated code motion.  I.e.
 
@@ -332,11 +334,23 @@ enum move_pos
    Otherwise return MOVE_IMPOSSIBLE.  */
 
 enum move_pos
-movement_possibility (gimple *stmt)
+movement_possibility (gimple *stmt, bool restrict_oacc_hoisting)
 {
   tree lhs;
   enum move_pos ret = MOVE_POSSIBLE;
 
+  if (restrict_oacc_hoisting && oacc_get_fn_attrib (cfun->decl)
+      && gimple_code (stmt) == GIMPLE_ASSIGN)
+    {
+      tree rhs = gimple_assign_rhs1 (stmt);
+
+      if (TREE_CODE (rhs) == VIEW_CONVERT_EXPR)
+       rhs = TREE_OPERAND (rhs, 0);
+
+      if (TREE_CODE (rhs) == ARRAY_REF)
+         return MOVE_IMPOSSIBLE;
+    }
+
   if (flag_unswitch_loops
       && gimple_code (stmt) == GIMPLE_COND)
     {
@@ -1045,7 +1059,7 @@ rewrite_bittest (gimple_stmt_iterator *bsi)
    statements.  */
 
 static void
-compute_invariantness (basic_block bb)
+compute_invariantness (basic_block bb, bool restrict_oacc_hoisting)
 {
   enum move_pos pos;
   gimple_stmt_iterator bsi;
@@ -1073,7 +1087,7 @@ compute_invariantness (basic_block bb)
       {
        stmt = gsi_stmt (bsi);
 
-       pos = movement_possibility (stmt);
+       pos = movement_possibility (stmt, restrict_oacc_hoisting);
        if (pos == MOVE_IMPOSSIBLE)
          continue;
 
@@ -1104,7 +1118,7 @@ compute_invariantness (basic_block bb)
     {
       stmt = gsi_stmt (bsi);
 
-      pos = movement_possibility (stmt);
+      pos = movement_possibility (stmt, restrict_oacc_hoisting);
       if (pos == MOVE_IMPOSSIBLE)
        {
          if (nonpure_call_p (stmt))
@@ -1524,6 +1538,13 @@ gather_mem_refs_stmt (class loop *loop, gimple *stmt)
   if (!gimple_vuse (stmt))
     return;
 
+  /* The expansion of those OpenACC internal function calls which occurs in a
+   * later pass does not introduce any memory references. Hence it is safe to
+   * ignore them. */
+  if (gimple_call_internal_p (stmt, IFN_GOACC_LOOP)
+      || gimple_call_internal_p (stmt, IFN_UNIQUE))
+    return;
+
   mem = simple_mem_ref_in_stmt (stmt, &is_stored);
   if (!mem && is_gimple_assign (stmt))
     {
@@ -1565,7 +1586,7 @@ gather_mem_refs_stmt (class loop *loop, gimple *stmt)
       ao_ref_alias_set (&aor);
       HOST_WIDE_INT offset, size, max_size;
       poly_int64 saved_maxsize = aor.max_size, mem_off;
-      tree mem_base;
+      tree mem_base = NULL;
       bool ref_decomposed;
       if (aor.max_size_known_p ()
          && aor.offset.is_constant (&offset)
@@ -3518,7 +3539,8 @@ tree_ssa_lim_finalize (void)
    Only perform store motion if STORE_MOTION is true.  */
 
 unsigned int
-loop_invariant_motion_in_fun (function *fun, bool store_motion)
+loop_invariant_motion_in_fun (function *fun, bool store_motion,
+                             bool restrict_oacc_hoisting)
 {
   unsigned int todo = 0;
 
@@ -3546,7 +3568,7 @@ loop_invariant_motion_in_fun (function *fun, bool store_motion)
   /* For each statement determine the outermost loop in that it is
      invariant and cost for computing the invariant.  */
   for (int i = 0; i < n; ++i)
-    compute_invariantness (BASIC_BLOCK_FOR_FN (fun, rpo[i]));
+    compute_invariantness (BASIC_BLOCK_FOR_FN (fun, rpo[i]), restrict_oacc_hoisting);
 
   /* Execute store motion.  Force the necessary invariants to be moved
      out of the loops as well.  */
@@ -3593,13 +3615,21 @@ class pass_lim : public gimple_opt_pass
 {
 public:
   pass_lim (gcc::context *ctxt)
-    : gimple_opt_pass (pass_data_lim, ctxt)
+    : gimple_opt_pass (pass_data_lim, ctxt), restrict_oacc_hoisting (false)
   {}
 
+  void set_pass_param (unsigned int n, bool param)
+    {
+      gcc_assert (n == 0);
+      restrict_oacc_hoisting = param;
+    }
+
   /* opt_pass methods: */
   opt_pass * clone () { return new pass_lim (m_ctxt); }
   virtual bool gate (function *) { return flag_tree_loop_im != 0; }
   virtual unsigned int execute (function *);
+private:
+  bool restrict_oacc_hoisting;
 
 }; // class pass_lim
 
@@ -3612,7 +3642,16 @@ pass_lim::execute (function *fun)
 
   if (number_of_loops (fun) <= 1)
     return 0;
-  unsigned int todo = loop_invariant_motion_in_fun (fun, flag_move_loop_stores);
+
+  bool store_motion = flag_move_loop_stores;
+  /* TODO Enabling store motion in OpenACC kernel functions requires further
+     handling of the OpenACC internal function calls.  It can also be harmful
+     to data-dependence analysis. Keep it disabled for now. */
+  if (oacc_function_p (cfun) && graphite_analyze_oacc_target_region_type_p (cfun))
+    store_motion = false;
+
+  unsigned int todo = loop_invariant_motion_in_fun (fun, store_motion,
+                                                   restrict_oacc_hoisting);
 
   if (!in_loop_pipeline)
     loop_optimizer_finalize ();

diff --git a/gcc/tree-ssa-loop-manip.h b/gcc/tree-ssa-loop-manip.h
index 00293195e80dca712d3d67e423168fb2cb3ee704..e885ca4d12c27c13e75f4a6d8d6a52e47903462d 100644 (file)
--- a/gcc/tree-ssa-loop-manip.h
+++ b/gcc/tree-ssa-loop-manip.h
@@ -53,7 +53,7 @@ extern void tree_transform_and_unroll_loop (class loop *, unsigned,
                                            transform_callback, void *);
 extern void tree_unroll_loop (class loop *, unsigned, tree_niter_desc *);
 extern tree canonicalize_loop_ivs (class loop *, tree *, bool);
-extern unsigned int loop_invariant_motion_in_fun (function *, bool);
+extern unsigned int loop_invariant_motion_in_fun (function *, bool, bool);
 
 
 #endif /* GCC_TREE_SSA_LOOP_MANIP_H */